static void
constraint_editor_application_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
ConstraintEditorWindow *win;
- gint i;
+ int i;
for (i = 0; i < n_files; i++)
{
static void
open_response_cb (GtkNativeDialog *dialog,
- gint response,
+ int response,
ConstraintEditorWindow *self)
{
gtk_native_dialog_hide (dialog);
static void
save_response_cb (GtkNativeDialog *dialog,
- gint response,
+ int response,
ConstraintEditorWindow *self)
{
gtk_native_dialog_hide (dialog);
static void
open_response_cb (GtkNativeDialog *dialog,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GtkFileChooserNative *native = user_data;
DemoApplicationWindow *window)
{
gchar *msg;
- gint row, col;
- gint count;
+ int row, col;
+ int count;
GtkTextIter iter;
/* clear any previous message, underflow is allowed */
static void
on_assistant_prepare (GtkWidget *widget, GtkWidget *page, gpointer data)
{
- gint current_page, n_pages;
+ int current_page, n_pages;
gchar *title;
current_page = gtk_assistant_get_current_page (GTK_ASSISTANT (widget));
{
GtkAssistant *assistant = GTK_ASSISTANT (data);
GtkWidget *current_page;
- gint page_number;
+ int page_number;
const gchar *text;
page_number = gtk_assistant_get_current_page (assistant);
GtkTreeIter iter;
GtkListStore *store;
- gint i;
+ int i;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
gpointer data)
{
GtkTreePath *path;
- gint *indices;
+ int *indices;
gboolean sensitive;
path = gtk_tree_model_get_path (tree_model, iter);
GtkTreeIter iter, iter2;
GtkTreeStore *store;
- gint i;
+ int i;
store = gtk_tree_store_new (1, G_TYPE_STRING);
{
GtkWidget *normal_row;
GtkWidget *listbox;
- gint i;
+ int i;
normal_row = NULL;
listbox = gtk_list_box_new ();
gpointer user_data)
{
GtkWidget *dialog;
- static gint i = 1;
+ static int i = 1;
dialog = gtk_message_dialog_new (GTK_WINDOW (window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
typedef struct
{
- gint number;
+ int number;
gchar *product;
- gint yummy;
+ int yummy;
}
Item;
static GtkTreeModel *
create_items_model (void)
{
- gint i = 0;
+ int i = 0;
GtkListStore *model;
GtkTreeIter iter;
create_numbers_model (void)
{
#define N_NUMBERS 10
- gint i = 0;
+ int i = 0;
GtkListStore *model;
GtkTreeIter iter;
if (gtk_tree_selection_get_selected (selection, NULL, &iter))
{
- gint i;
+ int i;
GtkTreePath *path;
path = gtk_tree_model_get_path (model, &iter);
gpointer data)
{
GtkTreePath *path;
- gint idx;
+ int idx;
path = gtk_tree_model_get_path (model, iter);
idx = gtk_tree_path_get_indices (path)[0];
GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
GtkTreeIter iter;
- gint column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column"));
+ int column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column"));
gtk_tree_model_get_iter (model, &iter, path);
{
case COLUMN_ITEM_NUMBER:
{
- gint i;
+ int i;
i = gtk_tree_path_get_indices (path)[0];
g_array_index (articles, Item, i).number = atoi (new_text);
case COLUMN_ITEM_PRODUCT:
{
- gint i;
+ int i;
gchar *old_text;
gtk_tree_model_get (model, &iter, column, &old_text, -1);
static GtkWidget *window = NULL;
static void
-response_cb (GtkDialog *dialog, gint response_id)
+response_cb (GtkDialog *dialog, int response_id)
{
gtk_window_destroy (GTK_WINDOW (window));
window = NULL;
GtkTreeIter *iter,
gpointer data)
{
- gint num;
+ int num;
gchar *text;
gtk_tree_model_get (model, iter, GPOINTER_TO_INT (data), &num, -1);
filter_modify_func (GtkTreeModel *model,
GtkTreeIter *iter,
GValue *value,
- gint column,
+ int column,
gpointer data)
{
GtkTreeModelFilter *filter_model = GTK_TREE_MODEL_FILTER (model);
- gint width, height;
+ int width, height;
GtkTreeModel *child_model;
GtkTreeIter child_iter;
GtkTreeIter *iter,
gpointer data)
{
- gint width;
+ int width;
gtk_tree_model_get (model, iter,
WIDTH_COLUMN, &width,
"YellowGreen",
NULL
};
- gint i;
+ int i;
if (!window)
{
GList *l;
PangoAttrList *attrs;
PangoAttribute *attr;
- gint ins, bound;
+ int ins, bound;
guint start, end;
PangoLanguage *lang;
char *font_desc;
{
GtkListStore *store;
hb_font_t *hb_font;
- gint i, j, k;
+ int i, j, k;
PangoFont *pango_font;
GHashTable *tags;
GHashTableIter iter;
static void
update_features (void)
{
- gint i, j;
+ int i, j;
GtkTreeModel *model;
GtkTreeIter iter;
guint script_index, lang_index;
static void
val_to_xy (GtkFontPlane *plane,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
gdouble u, v;
- gint width, height;
+ int width, height;
width = gtk_widget_get_allocated_width (GTK_WIDGET (plane));
height = gtk_widget_get_allocated_height (GTK_WIDGET (plane));
GtkSnapshot *snapshot)
{
GtkFontPlane *plane = GTK_FONT_PLANE (widget);
- gint x, y;
- gint width, height;
+ int x, y;
+ int width, height;
cairo_t *cr;
val_to_xy (plane, &x, &y);
static void
update_value (GtkFontPlane *plane,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkWidget *widget = GTK_WIDGET (plane);
gdouble u, v;
GHashTableIter iter;
gpointer key, value;
GtkFishbowlChild *child;
- gint child_min, child_nat;
+ int child_min, child_nat;
*minimum = 0;
*natural = 0;
insert_link (GtkTextBuffer *buffer,
GtkTextIter *iter,
const char *text,
- gint page)
+ int page)
{
GtkTextTag *tag;
*/
static void
show_page (GtkTextBuffer *buffer,
- gint page)
+ int page)
{
GtkTextIter iter;
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
GtkTextTag *tag = tagp->data;
- gint page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "page"));
+ int page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "page"));
if (page != 0)
{
}
static void set_cursor_if_appropriate (GtkTextView *text_view,
- gint x,
- gint y);
+ int x,
+ int y);
static void
released_cb (GtkGestureClick *gesture,
*/
static void
set_cursor_if_appropriate (GtkTextView *text_view,
- gint x,
- gint y)
+ int x,
+ int y)
{
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
for (tagp = tags; tagp != NULL; tagp = tagp->next)
{
GtkTextTag *tag = tagp->data;
- gint page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "page"));
+ int page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "page"));
if (page != 0)
{
g_dir_close (dir);
}
-static gint
+static int
sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkTreeIter iter;
const gchar *text[] = { "Red", "Green", "Blue", "Yellow" };
- gint i;
+ int i;
/* First clear the store */
gtk_list_store_clear (store);
if (gdk_rgba_parse (&color, text))
pixel =
- ((gint)(color.red * 255)) << 24 |
- ((gint)(color.green * 255)) << 16 |
- ((gint)(color.blue * 255)) << 8 |
- ((gint)(color.alpha * 255));
+ ((int)(color.red * 255)) << 24 |
+ ((int)(color.green * 255)) << 16 |
+ ((int)(color.blue * 255)) << 8 |
+ ((int)(color.alpha * 255));
g_free (text);
static void
progressive_updated_callback (GdkPixbufLoader *loader,
- gint x,
- gint y,
- gint width,
- gint height,
+ int x,
+ int y,
+ int width,
+ int height,
gpointer data)
{
GtkWidget *picture;
gtk_picture_set_pixbuf (GTK_PICTURE (picture), pixbuf);
}
-static gint
+static int
progressive_timeout (gpointer data)
{
GtkWidget *picture;
static void
on_bar_response (GtkInfoBar *info_bar,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GtkWidget *dialog;
static void
response_cb (GtkWidget *dialog,
- gint response_id,
+ int response_id,
gpointer data)
{
gtk_window_destroy (GTK_WINDOW (dialog));
static GtkTreeModel *
create_model (void)
{
- gint i = 0;
+ int i = 0;
GtkListStore *store;
GtkTreeIter iter;
"static",
"const ",
"void",
- "gint",
" int ",
" char ",
"gchar ",
void
parse_chars (gchar *text,
gchar **end_ptr,
- gint *state,
+ int *state,
const char **tag,
gboolean start)
{
- gint i;
+ int i;
gchar *next_token;
/* Handle comments first */
/* check for string */
if (text[0] == '"')
{
- gint maybe_escape = FALSE;
+ int maybe_escape = FALSE;
*end_ptr = text + 1;
*tag = "string";
fontify (GtkTextBuffer *source_buffer)
{
GtkTextIter start_iter, next_iter, tmp_iter;
- gint state;
+ int state;
gchar *text;
gchar *start_ptr, *end_ptr;
const char *tag;
static void
remove_data_tabs (void)
{
- gint i;
+ int i;
for (i = gtk_notebook_get_n_pages (GTK_NOTEBOOK (notebook)) - 1; i > 1; i--)
gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), i);
gboolean in_para = 0;
gchar **lines;
GBytes *bytes;
- gint i;
+ int i;
if (!g_strcmp0 (current_file, filename))
return;
}
}
-static gint
+static int
command_line (GApplication *app,
GApplicationCommandLine *cmdline)
{
margin_changed (GtkAdjustment *adjustment,
GtkTextView *text)
{
- gint value;
+ int value;
- value = (gint)gtk_adjustment_get_value (adjustment);
+ value = (int)gtk_adjustment_get_value (adjustment);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (text), value);
g_object_set (tag, "pixels-above-lines", value, NULL);
}
#include <gtk/gtkunixprint.h>
static void
-done_cb (GtkDialog *dialog, gint response, gpointer data)
+done_cb (GtkDialog *dialog, int response, gpointer data)
{
gtk_window_destroy (GTK_WINDOW (dialog));
}
static void
drawing_area_ensure_surface (DrawingArea *area,
- gint width,
- gint height)
+ int width,
+ int height)
{
if (!area->surface ||
cairo_image_surface_get_width (area->surface) != width ||
GSimpleActionGroup *action_group;
GSimpleAction *action;
GtkWidget *toplevel;
- gint i;
+ int i;
GTK_WIDGET_CLASS (drawing_area_parent_class)->root (widget);
/* Background image */
static GdkPixbuf *background;
-static gint back_width, back_height;
+static int back_width, back_height;
/* Images */
static GdkPixbuf *images[N_IMAGES];
static gboolean
load_pixbufs (GError **error)
{
- gint i;
+ int i;
if (background)
return TRUE; /* already loaded earlier */
gchar *resourcename;
gdouble font_size;
- gint lines_per_page;
+ int lines_per_page;
gchar **lines;
- gint num_lines;
- gint num_pages;
+ int num_lines;
+ int num_pages;
} PrintData;
static void
static void
draw_page (GtkPrintOperation *operation,
GtkPrintContext *context,
- gint page_nr,
+ int page_nr,
gpointer user_data)
{
PrintData *data = (PrintData *)user_data;
cairo_t *cr;
PangoLayout *layout;
- gint text_width, text_height;
+ int text_width, text_height;
gdouble width;
- gint line, i;
+ int line, i;
PangoFontDescription *desc;
gchar *page_str;
#include <gtk/gtk.h>
-static gint count = 0;
+static int count = 0;
static guint timeout = 0;
static void
static void
icon_press_cb (GtkEntry *entry,
- gint position,
+ int position,
gpointer data)
{
if (position == GTK_ENTRY_ICON_PRIMARY)
#include <math.h>
#include <stdlib.h>
-gint
+int
spinbutton_hex_spin_input (GtkSpinButton *spin_button,
gdouble *new_val)
{
return TRUE;
}
-gint
+int
spinbutton_hex_spin_output (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
if (fabs (val) < 1e-5)
buf = g_strdup ("0x00");
else
- buf = g_strdup_printf ("0x%.2X", (gint) val);
+ buf = g_strdup_printf ("0x%.2X", (int) val);
if (strcmp (buf, gtk_editable_get_text (GTK_EDITABLE (spin_button))))
gtk_editable_set_text (GTK_EDITABLE (spin_button), buf);
g_free (buf);
return TRUE;
}
-gint
+int
spinbutton_time_spin_input (GtkSpinButton *spin_button,
gdouble *new_val)
{
const gchar *text;
gchar **str;
gboolean found = FALSE;
- gint hours;
- gint minutes;
+ int hours;
+ int minutes;
gchar *endh;
gchar *endm;
return TRUE;
}
-gint
+int
spinbutton_time_spin_output (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
"December"
};
-gint
+int
spinbutton_month_spin_input (GtkSpinButton *spin_button,
gdouble *new_val)
{
- gint i;
+ int i;
gchar *tmp1, *tmp2;
gboolean found = FALSE;
return TRUE;
}
-gint
+int
spinbutton_month_spin_output (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
gdouble value;
- gint i;
+ int i;
adjustment = gtk_spin_button_get_adjustment (spin_button);
value = gtk_adjustment_get_value (adjustment);
GtkTreeIter iter;
gboolean toggle_item;
- gint *column;
+ int *column;
column = g_object_get_data (G_OBJECT (cell), "column");
static void
add_columns (GtkTreeView *treeview)
{
- gint col_offset;
+ int col_offset;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
/* alex column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
- g_object_set_data (G_OBJECT (renderer), "column", (gint *)ALEX_COLUMN);
+ g_object_set_data (G_OBJECT (renderer), "column", (int *)ALEX_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
/* havoc column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
- g_object_set_data (G_OBJECT (renderer), "column", (gint *)HAVOC_COLUMN);
+ g_object_set_data (G_OBJECT (renderer), "column", (int *)HAVOC_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
/* tim column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
- g_object_set_data (G_OBJECT (renderer), "column", (gint *)TIM_COLUMN);
+ g_object_set_data (G_OBJECT (renderer), "column", (int *)TIM_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
/* owen column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
- g_object_set_data (G_OBJECT (renderer), "column", (gint *)OWEN_COLUMN);
+ g_object_set_data (G_OBJECT (renderer), "column", (int *)OWEN_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
/* dave column */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
- g_object_set_data (G_OBJECT (renderer), "column", (gint *)DAVE_COLUMN);
+ g_object_set_data (G_OBJECT (renderer), "column", (int *)DAVE_COLUMN);
g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model);
}
static void
-set_image (GtkWidget *image, const gchar *name, gint size)
+set_image (GtkWidget *image, const gchar *name, int size)
{
gtk_image_set_from_icon_name (GTK_IMAGE (image), name);
gtk_image_set_pixel_size (GTK_IMAGE (image), size);
static void
node_editor_application_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
NodeEditorWindow *win;
- gint i;
+ int i;
for (i = 0; i < n_files; i++)
{
if (keyboard_tip)
{
- gint offset;
+ int offset;
g_object_get (self->text_buffer, "cursor-position", &offset, NULL);
gtk_text_buffer_get_iter_at_offset (self->text_buffer, &iter, offset);
}
else
{
- gint bx, by, trailing;
+ int bx, by, trailing;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (self->text_view), GTK_TEXT_WINDOW_TEXT,
x, y, &bx, &by);
static void
open_response_cb (GtkWidget *dialog,
- gint response,
+ int response,
NodeEditorWindow *self)
{
gtk_widget_hide (dialog);
static void
save_response_cb (GtkWidget *dialog,
- gint response,
+ int response,
NodeEditorWindow *self)
{
gtk_widget_hide (dialog);
static void
export_image_response_cb (GtkWidget *dialog,
- gint response,
+ int response,
GdkTexture *texture)
{
gtk_widget_hide (dialog);
update_statusbar (void)
{
gchar *msg;
- gint row, col;
+ int row, col;
GtkTextIter iter;
const char *print_str;
gtk_widget_set_sensitive (window, FALSE);
}
-static gint current_page = 0;
+static int current_page = 0;
static gboolean
-on_page (gint i)
+on_page (int i)
{
return current_page == i;
}
spin_value_changed (GtkAdjustment *adjustment, GtkWidget *label)
{
GtkWidget *w;
- gint v;
+ int v;
gchar *text;
v = (int)gtk_adjustment_get_value (adjustment);
dismiss (button);
}
-static gint pulse_time = 250;
-static gint pulse_entry_mode = 0;
+static int pulse_time = 250;
+static int pulse_entry_mode = 0;
static void
remove_pulse (gpointer pulse_id)
}
else
{
- gint percent;
+ int percent;
- percent = (gint) (100. * val / (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_lower (adjustment)) + .5);
+ percent = (int) (100. * val / (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_lower (adjustment)) + .5);
str = g_strdup_printf (C_("volume percentage", "%d %%"), percent);
}
on_range_from_changed (GtkSpinButton *from)
{
GtkSpinButton *to;
- gint v1, v2;
+ int v1, v2;
to = GTK_SPIN_BUTTON (g_object_get_data (G_OBJECT (from), "range_to_spin"));
on_range_to_changed (GtkSpinButton *to)
{
GtkSpinButton *from;
- gint v1, v2;
+ int v1, v2;
from = GTK_SPIN_BUTTON (g_object_get_data (G_OBJECT (to), "range_from_spin"));
}
static void
-info_bar_response (GtkWidget *infobar, gint response_id)
+info_bar_response (GtkWidget *infobar, int response_id)
{
if (response_id == GTK_RESPONSE_CLOSE)
gtk_widget_hide (infobar);
{ "7.5", "#C48299", NULL },
{ "10", "#C68292", NULL }
};
- gint i;
+ int i;
GtkWidget *row, *box, *label, *swatch;
GtkWidget *sw;
GdkRGBA rgba;
}
static void
-close_selection_dialog (GtkWidget *dialog, gint response, GtkWidget *tv)
+close_selection_dialog (GtkWidget *dialog, int response, GtkWidget *tv)
{
GtkWidget *box;
GtkWidget *child;
{ "app.paste", { "<Control>v", NULL } },
{ "win.delete", { "Delete", NULL } },
};
- gint i;
+ int i;
GPermission *permission;
GAction *action;
GError *error = NULL;
{ "check-off-disabled", NULL, NULL, "false", NULL },
{ "radio-x-disabled", NULL, "s", "'x'", NULL },
};
- gint status;
+ int status;
app = gtk_application_new ("org.gtk.WidgetFactory4", G_APPLICATION_NON_UNIQUE);
void gtk_type_set_prop (GtkType *type,
gfloat value);
gfloat gtk_type_get_prop (GtkType *type);
- gint gtk_type_update_foobar (GtkType *type);
+ int gtk_type_update_foobar (GtkType *type);
```
Public headers should never be included directly:
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
XWindowAttributes attrs;
Window xid;
Display *dpy;
- gint x = 0, y = 0;
- gint width, height;
+ int x = 0, y = 0;
+ int width, height;
GdkPixbuf *tmp, *tmp2;
GdkPixbuf *retval = NULL;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
static void
example_app_open (GApplication *app,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
GList *windows;
{
GtkWindow *window = user_data;
BloatPad *app;
- gint old_n, n;
+ int old_n, n;
app = (BloatPad *) gtk_window_get_application (window);
static void
bloat_pad_open (GApplication *application,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
- gint i;
+ int i;
for (i = 0; i < n_files; i++)
new_window (application, files[i]);
GtkWidget *entry;
gchar **actions;
GtkWidget *dialog;
- gint i;
+ int i;
dialog = gtk_dialog_new ();
gtk_window_set_application (GTK_WINDOW (dialog), app);
dump_accels (GtkApplication *app)
{
gchar **actions;
- gint i;
+ int i;
actions = gtk_application_list_action_descriptions (app);
for (i = 0; actions[i]; i++)
GIcon *icon2;
GEmblem *emblem;
GFile *file;
- gint i;
+ int i;
struct {
const gchar *action_and_target;
const gchar *accelerators[2];
static void
plug_man_open (GApplication *application,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
- gint i;
+ int i;
for (i = 0; i < n_files; i++)
new_window (application, files[i]);
plugin_menu = find_plugin_menu ();
if (plugin_menu)
{
- gint i;
+ int i;
for (i = 0; i < g_menu_model_get_n_items (plugin_menu); i++)
{
gtk_search_bar_set_key_capture_widget (GTK_SEARCH_BAR (search_bar), window);
}
-gint
-main (gint argc,
+int
+main (int argc,
gchar *argv[])
{
GtkApplication *app;
static void
open (GApplication *application,
GFile **files,
- gint n_files,
+ int n_files,
const gchar *hint)
{
- gint i;
+ int i;
for (i = 0; i < n_files; i++)
new_window (application, files[i]);
append_uint16 (output, parent_id);
}
-static gint append_node_depth = -1;
+static int append_node_depth = -1;
static void
append_type (BroadwayOutput *output, guint32 type, BroadwayNode *node)
GList *surfaces;
BroadwaySurface *root;
gint32 focused_surface_id; /* -1 => none */
- gint show_keyboard;
+ int show_keyboard;
guint32 next_texture_id;
GHashTable *textures;
static void
broadway_server_fake_roundtrip_reply (BroadwayServer *server,
- gint id,
+ int id,
guint32 tag)
{
BroadwayInputMsg msg;
void
broadway_server_roundtrip (BroadwayServer *server,
- gint id,
+ int id,
guint32 tag)
{
if (server->output)
void
broadway_server_destroy_surface (BroadwayServer *server,
- gint id)
+ int id)
{
BroadwaySurface *surface;
gboolean
broadway_server_surface_show (BroadwayServer *server,
- gint id)
+ int id)
{
BroadwaySurface *surface;
gboolean sent = FALSE;
gboolean
broadway_server_surface_hide (BroadwayServer *server,
- gint id)
+ int id)
{
BroadwaySurface *surface;
gboolean sent = FALSE;
void
broadway_server_surface_raise (BroadwayServer *server,
- gint id)
+ int id)
{
BroadwaySurface *surface;
void
broadway_server_surface_lower (BroadwayServer *server,
- gint id)
+ int id)
{
BroadwaySurface *surface;
void
broadway_server_surface_set_transient_for (BroadwayServer *server,
- gint id, gint parent)
+ int id, int parent)
{
BroadwaySurface *surface;
/* passes ownership of nodes */
void
broadway_server_surface_update_nodes (BroadwayServer *server,
- gint id,
+ int id,
guint32 data[],
int len,
GHashTable *client_texture_map)
gboolean
broadway_server_surface_move_resize (BroadwayServer *server,
- gint id,
+ int id,
gboolean with_move,
int x,
int y,
void
broadway_server_focus_surface (BroadwayServer *server,
- gint new_focused_surface)
+ int new_focused_surface)
{
BroadwayInputMsg focus_msg;
guint32
broadway_server_grab_pointer (BroadwayServer *server,
- gint client_id,
- gint id,
+ int client_id,
+ int id,
gboolean owner_events,
guint32 event_mask,
guint32 time_)
void broadway_server_flush (BroadwayServer *server);
void broadway_server_sync (BroadwayServer *server);
void broadway_server_roundtrip (BroadwayServer *server,
- gint id,
+ int id,
guint32 tag);
void broadway_server_get_screen_size (BroadwayServer *server,
guint32 *width,
gint32 *root_y,
guint32 *mask);
guint32 broadway_server_grab_pointer (BroadwayServer *server,
- gint client_id,
- gint id,
+ int client_id,
+ int id,
gboolean owner_events,
guint32 event_mask,
guint32 time_);
int width,
int height);
void broadway_server_destroy_surface (BroadwayServer *server,
- gint id);
+ int id);
gboolean broadway_server_surface_show (BroadwayServer *server,
- gint id);
+ int id);
gboolean broadway_server_surface_hide (BroadwayServer *server,
- gint id);
+ int id);
void broadway_server_surface_raise (BroadwayServer *server,
- gint id);
+ int id);
void broadway_server_surface_lower (BroadwayServer *server,
- gint id);
+ int id);
void broadway_server_surface_set_transient_for (BroadwayServer *server,
- gint id,
- gint parent);
+ int id,
+ int parent);
gboolean broadway_server_surface_translate (BroadwayServer *server,
- gint id,
+ int id,
cairo_region_t *area,
- gint dx,
- gint dy);
+ int dx,
+ int dy);
guint32 broadway_server_upload_texture (BroadwayServer *server,
GBytes *texture);
void broadway_server_release_texture (BroadwayServer *server,
cairo_surface_t * broadway_server_create_surface (int width,
int height);
void broadway_server_surface_update_nodes (BroadwayServer *server,
- gint id,
+ int id,
guint32 data[],
int len,
GHashTable *client_texture_map);
gboolean broadway_server_surface_move_resize (BroadwayServer *server,
- gint id,
+ int id,
gboolean with_move,
int x,
int y,
int width,
int height);
void broadway_server_focus_surface (BroadwayServer *server,
- gint new_focused_surface);
+ int new_focused_surface);
#endif /* __BROADWAY_SERVER__ */
void
_gdk_broadway_server_destroy_surface (GdkBroadwayServer *server,
- gint id)
+ int id)
{
BroadwayRequestDestroySurface msg;
gboolean
_gdk_broadway_server_surface_show (GdkBroadwayServer *server,
- gint id)
+ int id)
{
BroadwayRequestShowSurface msg;
gboolean
_gdk_broadway_server_surface_hide (GdkBroadwayServer *server,
- gint id)
+ int id)
{
BroadwayRequestHideSurface msg;
void
_gdk_broadway_server_surface_focus (GdkBroadwayServer *server,
- gint id)
+ int id)
{
BroadwayRequestFocusSurface msg;
void
_gdk_broadway_server_surface_set_transient_for (GdkBroadwayServer *server,
- gint id, gint parent)
+ int id, int parent)
{
BroadwayRequestSetTransientFor msg;
gboolean
_gdk_broadway_server_surface_move_resize (GdkBroadwayServer *server,
- gint id,
+ int id,
gboolean with_move,
int x,
int y,
GdkGrabStatus
_gdk_broadway_server_grab_pointer (GdkBroadwayServer *server,
- gint id,
+ int id,
gboolean owner_events,
guint32 event_mask,
guint32 time_)
gint32 *root_y,
guint32 *mask);
GdkGrabStatus _gdk_broadway_server_grab_pointer (GdkBroadwayServer *server,
- gint id,
+ int id,
gboolean owner_events,
guint32 event_mask,
guint32 time_);
int width,
int height);
void _gdk_broadway_server_destroy_surface (GdkBroadwayServer *server,
- gint id);
+ int id);
gboolean _gdk_broadway_server_surface_show (GdkBroadwayServer *server,
- gint id);
+ int id);
gboolean _gdk_broadway_server_surface_hide (GdkBroadwayServer *server,
- gint id);
+ int id);
void _gdk_broadway_server_surface_focus (GdkBroadwayServer *server,
- gint id);
+ int id);
void _gdk_broadway_server_surface_set_transient_for (GdkBroadwayServer *server,
- gint id,
- gint parent);
+ int id,
+ int parent);
void _gdk_broadway_server_set_show_keyboard (GdkBroadwayServer *server,
gboolean show_keyboard);
gboolean _gdk_broadway_server_surface_translate (GdkBroadwayServer *server,
- gint id,
+ int id,
cairo_region_t *area,
- gint dx,
- gint dy);
+ int dx,
+ int dy);
guint32 gdk_broadway_server_upload_texture (GdkBroadwayServer *server,
GdkTexture *texture);
void gdk_broadway_server_release_texture (GdkBroadwayServer *server,
guint32 id,
GArray *nodes);
gboolean _gdk_broadway_server_surface_move_resize (GdkBroadwayServer *server,
- gint id,
+ int id,
gboolean with_move,
int x,
int y,
#include <stdlib.h>
static gboolean gdk_event_source_prepare (GSource *source,
- gint *timeout);
+ int *timeout);
static gboolean gdk_event_source_check (GSource *source);
static gboolean gdk_event_source_dispatch (GSource *source,
GSourceFunc callback,
static gboolean
gdk_event_source_prepare (GSource *source,
- gint *timeout)
+ int *timeout)
{
GdkDisplay *display = ((GdkEventSource*) source)->display;
gboolean retval;
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries)
+ int *n_entries)
{
if (n_entries)
*n_entries = 1;
gdk_broadway_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers)
{
if (keyval)
double dy);
void _gdk_broadway_surface_translate (GdkSurface *surface,
cairo_region_t *area,
- gint dx,
- gint dy);
+ int dx,
+ int dy);
gboolean _gdk_broadway_moveresize_handle_event (GdkDisplay *display,
BroadwayInputMsg *msg);
gboolean _gdk_broadway_moveresize_configure_done (GdkDisplay *display,
gulong serial);
void gdk_broadway_surface_move_resize (GdkSurface *surface,
- gint x,
- gint y,
- gint width,
- gint height);
+ int x,
+ int y,
+ int width,
+ int height);
void _gdk_keymap_keys_changed (GdkDisplay *display);
-gint _gdk_broadway_get_group_for_state (GdkDisplay *display,
+int _gdk_broadway_get_group_for_state (GdkDisplay *display,
GdkModifierType state);
void _gdk_keymap_add_virtual_modifiers_compat (GdkKeymap *keymap,
GdkModifierType *modifiers);
_gdk_surface_clear_update_area (surface);
}
-static gint
+static int
gdk_broadway_surface_get_scale_factor (GdkSurface *surface)
{
GdkBroadwayDisplay *broadway_display;
static void
gdk_broadway_surface_move_resize_internal (GdkSurface *surface,
gboolean with_move,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
GdkBroadwaySurface *impl = GDK_BROADWAY_SURFACE (surface);
GdkBroadwayDisplay *broadway_display;
void
gdk_broadway_surface_move_resize (GdkSurface *surface,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
gdk_broadway_surface_move_resize_internal (surface, TRUE,
x, y,
static void
gdk_broadway_surface_toplevel_resize (GdkSurface *surface,
- gint width,
- gint height)
+ int width,
+ int height)
{
gdk_broadway_surface_move_resize_internal (surface, FALSE,
0, 0,
static void
gdk_broadway_surface_move (GdkSurface *surface,
- gint x,
- gint y)
+ int x,
+ int y)
{
gdk_broadway_surface_move_resize_internal (surface, TRUE, x, y, -1, -1);
}
static void
gdk_broadway_surface_get_geometry (GdkSurface *surface,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+ int *x,
+ int *y,
+ int *width,
+ int *height)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
static void
gdk_broadway_surface_get_root_coords (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y)
+ int x,
+ int y,
+ int *root_x,
+ int *root_y)
{
GdkBroadwaySurface *impl;
GdkSurface *moveresize_emulation_surface;
gboolean is_resize;
GdkSurfaceEdge resize_edge;
- gint moveresize_button;
- gint moveresize_x;
- gint moveresize_y;
- gint moveresize_orig_x;
- gint moveresize_orig_y;
- gint moveresize_orig_width;
- gint moveresize_orig_height;
+ int moveresize_button;
+ int moveresize_x;
+ int moveresize_y;
+ int moveresize_orig_x;
+ int moveresize_orig_y;
+ int moveresize_orig_width;
+ int moveresize_orig_height;
long moveresize_process_time;
GdkSurfaceHints moveresize_geom_mask;
GdkGeometry moveresize_geometry;
static void
update_pos (MoveResizeData *mv_resize,
- gint new_root_x,
- gint new_root_y)
+ int new_root_x,
+ int new_root_y)
{
- gint dx, dy;
+ int dx, dy;
dx = new_root_x - mv_resize->moveresize_x;
dy = new_root_y - mv_resize->moveresize_y;
if (mv_resize->is_resize)
{
- gint x, y, w, h;
+ int x, y, w, h;
x = mv_resize->moveresize_orig_x;
y = mv_resize->moveresize_orig_y;
}
else
{
- gint x, y;
+ int x, y;
x = mv_resize->moveresize_orig_x + dx;
y = mv_resize->moveresize_orig_y + dy;
static void
calculate_unmoving_origin (MoveResizeData *mv_resize)
{
- gint x, y, width, height;
+ int x, y, width, height;
if (mv_resize->moveresize_geom_mask & GDK_HINT_WIN_GRAVITY &&
mv_resize->moveresize_geometry.win_gravity == GDK_GRAVITY_STATIC)
PangoDirection
gdk_find_base_dir (const gchar *text,
- gint length)
+ int length)
{
PangoDirection dir = PANGO_DIRECTION_NEUTRAL;
const gchar *p;
*/
void
gdk_app_launch_context_set_desktop (GdkAppLaunchContext *context,
- gint desktop)
+ int desktop)
{
g_return_if_fail (GDK_IS_APP_LAUNCH_CONTEXT (context));
GDK_AVAILABLE_IN_ALL
void gdk_app_launch_context_set_desktop (GdkAppLaunchContext *context,
- gint desktop);
+ int desktop);
GDK_AVAILABLE_IN_ALL
void gdk_app_launch_context_set_timestamp (GdkAppLaunchContext *context,
guint32 timestamp);
GAppLaunchContext parent_instance;
GdkDisplay *display;
- gint workspace;
+ int workspace;
guint32 timestamp;
GIcon *icon;
char *icon_name;
const cairo_region_t *region)
{
cairo_rectangle_int_t box;
- gint n_boxes, i;
+ int n_boxes, i;
g_return_if_fail (cr != NULL);
g_return_if_fail (region != NULL);
gdk_cairo_surface_paint_pixbuf (cairo_surface_t *surface,
const GdkPixbuf *pixbuf)
{
- gint width, height;
+ int width, height;
guchar *gdk_pixels, *cairo_pixels;
int gdk_rowstride, cairo_stride;
int n_channels;
GdkRectangle extents, rect;
cairo_surface_t *image;
cairo_t *cr;
- gint x, y, stride;
+ int x, y, stride;
guchar *data;
_gdk_cairo_surface_extents (surface, &extents);
for (x = 0; x < extents.width; x++)
{
/* Search for a continuous range of "non transparent pixels"*/
- gint x0 = x;
+ int x0 = x;
while (x < extents.width)
{
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
*
* Returns: the number of axes.
**/
-gint
+int
gdk_device_get_n_axes (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
GdkAxisUse use,
gdouble *value)
{
- gint i;
+ int i;
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
g_return_val_if_fail (device->source != GDK_SOURCE_KEYBOARD, FALSE);
void
_gdk_device_reset_axes (GdkDevice *device)
{
- gint i;
+ int i;
for (i = device->axes->len - 1; i >= 0; i--)
g_array_remove_index (device->axes, i);
GdkAxisUse use)
{
GdkAxisInfo *info;
- gint i;
+ int i;
for (i = 0; i < GDK_AXIS_LAST; i++)
{
gdouble x_min, y_min;
gdouble x_resolution, y_resolution;
gdouble device_aspect;
- gint surface_width, surface_height;
+ int surface_width, surface_height;
if (index_ >= device->axes->len)
return FALSE;
double *win_y);
GDK_AVAILABLE_IN_ALL
-gint gdk_device_get_n_axes (GdkDevice *device);
+int gdk_device_get_n_axes (GdkDevice *device);
GDK_AVAILABLE_IN_ALL
gboolean gdk_device_get_axis (GdkDevice *device,
gdouble *axes,
*
* Returns: The number of button/ring/strip groups in the pad.
**/
-gint
+int
gdk_device_pad_get_n_groups (GdkDevicePad *pad)
{
GdkDevicePadInterface *iface = GDK_DEVICE_PAD_GET_IFACE (pad);
*
* Returns: The number of modes available in @group.
**/
-gint
+int
gdk_device_pad_get_group_n_modes (GdkDevicePad *pad,
- gint group_idx)
+ int group_idx)
{
GdkDevicePadInterface *iface = GDK_DEVICE_PAD_GET_IFACE (pad);
*
* Returns: The amount of elements of type @feature that this pad has.
**/
-gint
+int
gdk_device_pad_get_n_features (GdkDevicePad *pad,
GdkDevicePadFeature feature)
{
*
* Returns: The group number of the queried pad feature.
**/
-gint
+int
gdk_device_pad_get_feature_group (GdkDevicePad *pad,
GdkDevicePadFeature feature,
- gint idx)
+ int idx)
{
GdkDevicePadInterface *iface = GDK_DEVICE_PAD_GET_IFACE (pad);
GType gdk_device_pad_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-gint gdk_device_pad_get_n_groups (GdkDevicePad *pad);
+int gdk_device_pad_get_n_groups (GdkDevicePad *pad);
GDK_AVAILABLE_IN_ALL
-gint gdk_device_pad_get_group_n_modes (GdkDevicePad *pad,
- gint group_idx);
+int gdk_device_pad_get_group_n_modes (GdkDevicePad *pad,
+ int group_idx);
GDK_AVAILABLE_IN_ALL
-gint gdk_device_pad_get_n_features (GdkDevicePad *pad,
+int gdk_device_pad_get_n_features (GdkDevicePad *pad,
GdkDevicePadFeature feature);
GDK_AVAILABLE_IN_ALL
-gint gdk_device_pad_get_feature_group (GdkDevicePad *pad,
+int gdk_device_pad_get_feature_group (GdkDevicePad *pad,
GdkDevicePadFeature feature,
- gint feature_idx);
+ int feature_idx);
G_END_DECLS
struct _GdkDevicePadInterface {
GTypeInterface parent_interface;
- gint (* get_n_groups) (GdkDevicePad *pad);
+ int (* get_n_groups) (GdkDevicePad *pad);
- gint (* get_group_n_modes) (GdkDevicePad *pad,
- gint group);
- gint (* get_n_features) (GdkDevicePad *pad,
+ int (* get_group_n_modes) (GdkDevicePad *pad,
+ int group);
+ int (* get_n_features) (GdkDevicePad *pad,
GdkDevicePadFeature feature);
- gint (* get_feature_group) (GdkDevicePad *pad,
+ int (* get_feature_group) (GdkDevicePad *pad,
GdkDevicePadFeature feature,
- gint idx);
+ int idx);
};
G_END_DECLS
gdouble *axis_value);
GdkTimeCoord ** _gdk_device_allocate_history (GdkDevice *device,
- gint n_events);
+ int n_events);
void _gdk_device_add_physical_device (GdkDevice *device,
GdkDevice *physical);
const gchar *backend_list;
GdkDisplay *display;
gchar **backends;
- gint i, j;
+ int i, j;
gboolean allow_any;
if (allowed_backends == NULL)
*/
void
gdk_drag_set_hotspot (GdkDrag *drag,
- gint hot_x,
- gint hot_y)
+ int hot_x,
+ int hot_y)
{
g_return_if_fail (GDK_IS_DRAG (drag));
gdk_drag_get_cursor (GdkDrag *drag,
GdkDragAction action)
{
- gint i;
+ int i;
for (i = 0 ; i < G_N_ELEMENTS (drag_cursors) - 1; i++)
if (drag_cursors[i].action == action)
GDK_AVAILABLE_IN_ALL
void gdk_drag_set_hotspot (GdkDrag *drag,
- gint hot_x,
- gint hot_y);
+ int hot_x,
+ int hot_y);
GDK_AVAILABLE_IN_ALL
GdkContentProvider *
GdkSurface* (*get_drag_surface) (GdkDrag *drag);
void (*set_hotspot) (GdkDrag *drag,
- gint hot_x,
- gint hot_y);
+ int hot_x,
+ int hot_y);
void (*drop_done) (GdkDrag *drag,
gboolean success);
GdkMotionEvent *self = (GdkMotionEvent *) event;
GdkTimeCoord hist;
GdkDevice *device;
- gint i, n_axes;
+ int i, n_axes;
g_assert (GDK_IS_EVENT_TYPE (event, GDK_MOTION_NOTIFY));
g_assert (GDK_IS_EVENT_TYPE (history_event, GDK_MOTION_NOTIFY));
struct _GdkFrameClockPrivate
{
gint64 frame_counter;
- gint n_timings;
- gint current;
+ int n_timings;
+ int current;
GdkFrameTimings *timings[FRAME_HISTORY_MAX_LENGTH];
- gint n_freeze_inhibitors;
+ int n_freeze_inhibitors;
};
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkFrameClock, gdk_frame_clock, G_TYPE_OBJECT)
gint64 frame_counter)
{
GdkFrameClockPrivate *priv;
- gint pos;
+ int pos;
g_return_val_if_fail (GDK_IS_FRAME_CLOCK (frame_clock), NULL);
static gboolean
sleep_source_prepare (GSource *source,
- gint *timeout)
+ int *timeout)
{
sleep_source_prepare_time = g_source_get_time (source);
*timeout = -1;
void gdk_surface_get_root_coords (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y);
+ int x,
+ int y,
+ int *root_x,
+ int *root_y);
void gdk_surface_get_origin (GdkSurface *surface,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
void gdk_surface_get_geometry (GdkSurface *surface,
- gint *x,
- gint *y,
- gint *width,
- gint *height);
+ int *x,
+ int *y,
+ int *width,
+ int *height);
GdkGLContext *gdk_surface_get_shared_data_gl_context (GdkSurface *surface);
struct _GdkGeometry
{
- gint min_width;
- gint min_height;
- gint max_width;
- gint max_height;
- gint base_width;
- gint base_height;
- gint width_inc;
- gint height_inc;
+ int min_width;
+ int min_height;
+ int max_width;
+ int max_height;
+ int base_width;
+ int base_height;
+ int width_inc;
+ int height_inc;
gdouble min_aspect;
gdouble max_aspect;
GdkGravity win_gravity;
GDK_AVAILABLE_IN_ALL
void gdk_surface_constrain_size (GdkGeometry *geometry,
GdkSurfaceHints flags,
- gint width,
- gint height,
- gint *new_width,
- gint *new_height);
+ int width,
+ int height,
+ int *new_width,
+ int *new_height);
/*
* GdkSeatGrabPrepareFunc:
void gdk_surface_begin_resize_drag (GdkSurface *surface,
GdkSurfaceEdge edge,
GdkDevice *device,
- gint button,
- gint x,
- gint y,
+ int button,
+ int x,
+ int y,
guint32 timestamp);
void gdk_surface_begin_move_drag (GdkSurface *surface,
GdkDevice *device,
- gint button,
- gint x,
- gint y,
+ int button,
+ int x,
+ int y,
guint32 timestamp);
G_END_DECLS
gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap,
guint keyval,
GdkKeymapKey **keys,
- gint *n_keys)
+ int *n_keys)
{
GArray *array;
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries)
+ int *n_entries)
{
g_return_val_if_fail (GDK_IS_KEYMAP (keymap), FALSE);
g_return_val_if_fail (n_entries != NULL, FALSE);
gdk_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers)
{
g_return_val_if_fail (GDK_IS_KEYMAP (keymap), FALSE);
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries);
+ int *n_entries);
guint (* lookup_key) (GdkKeymap *keymap,
const GdkKeymapKey *key);
gboolean (* translate_keyboard_state) (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers);
guint (* get_modifier_state) (GdkKeymap *keymap);
gboolean gdk_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers);
gboolean gdk_keymap_get_entries_for_keyval (GdkKeymap *keymap,
guint keyval,
GdkKeymapKey **keys,
- gint *n_keys);
+ int *n_keys);
gboolean gdk_keymap_get_entries_for_keycode (GdkKeymap *keymap,
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries);
+ int *n_entries);
PangoDirection gdk_keymap_get_direction (GdkKeymap *keymap);
gboolean gdk_keymap_have_bidi_layouts (GdkKeymap *keymap);
*/
static cairo_region_t*
layout_iter_get_line_clip_region (PangoLayoutIter *iter,
- gint x_origin,
- gint y_origin,
- const gint *index_ranges,
- gint n_ranges)
+ int x_origin,
+ int y_origin,
+ const int *index_ranges,
+ int n_ranges)
{
PangoLayoutLine *line;
cairo_region_t *clip_region;
PangoRectangle logical_rect;
- gint baseline;
- gint i;
+ int baseline;
+ int i;
line = pango_layout_iter_get_line_readonly (iter);
i = 0;
while (i < n_ranges)
{
- gint *pixel_ranges = NULL;
- gint n_pixel_ranges = 0;
- gint j;
+ int *pixel_ranges = NULL;
+ int n_pixel_ranges = 0;
+ int j;
/* Note that get_x_ranges returns layout coordinates
*/
**/
cairo_region_t*
gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,
- gint x_origin,
- gint y_origin,
- const gint *index_ranges,
- gint n_ranges)
+ int x_origin,
+ int y_origin,
+ const int *index_ranges,
+ int n_ranges)
{
cairo_region_t *clip_region;
PangoLayoutIter *iter;
**/
cairo_region_t*
gdk_pango_layout_get_clip_region (PangoLayout *layout,
- gint x_origin,
- gint y_origin,
- const gint *index_ranges,
- gint n_ranges)
+ int x_origin,
+ int y_origin,
+ const int *index_ranges,
+ int n_ranges)
{
PangoLayoutIter *iter;
cairo_region_t *clip_region;
{
PangoRectangle logical_rect;
cairo_region_t *line_region;
- gint baseline;
+ int baseline;
pango_layout_iter_get_line_extents (iter, NULL, &logical_rect);
baseline = pango_layout_iter_get_baseline (iter);
GDK_AVAILABLE_IN_ALL
cairo_region_t *gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,
- gint x_origin,
- gint y_origin,
- const gint *index_ranges,
- gint n_ranges);
+ int x_origin,
+ int y_origin,
+ const int *index_ranges,
+ int n_ranges);
GDK_AVAILABLE_IN_ALL
cairo_region_t *gdk_pango_layout_get_clip_region (PangoLayout *layout,
- gint x_origin,
- gint y_origin,
- const gint *index_ranges,
- gint n_ranges);
+ int x_origin,
+ int y_origin,
+ const int *index_ranges,
+ int n_ranges);
G_END_DECLS
struct _GdkIOPipe
{
- gint ref_count;
+ int ref_count;
GMutex mutex;
GCond cond;
*/
GdkPixbuf *
gdk_pixbuf_get_from_surface (cairo_surface_t *surface,
- gint src_x,
- gint src_y,
- gint width,
- gint height)
+ int src_x,
+ int src_y,
+ int width,
+ int height)
{
cairo_content_t content;
GdkPixbuf *dest;
GDK_AVAILABLE_IN_ALL
GdkPixbuf *gdk_pixbuf_get_from_surface (cairo_surface_t *surface,
- gint src_x,
- gint src_y,
- gint width,
- gint height);
+ int src_x,
+ int src_y,
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
GdkPixbuf *gdk_pixbuf_get_from_texture (GdkTexture *texture);
const GdkRectangle *src2,
GdkRectangle *dest)
{
- gint dest_x, dest_y;
+ int dest_x, dest_y;
g_return_if_fail (src1 != NULL);
g_return_if_fail (src2 != NULL);
const GdkRectangle *src2,
GdkRectangle *dest)
{
- gint dest_x, dest_y;
- gint dest_x2, dest_y2;
- gint return_val;
+ int dest_x, dest_y;
+ int dest_x2, dest_y2;
+ int return_val;
g_return_val_if_fail (src1 != NULL, FALSE);
g_return_val_if_fail (src2 != NULL, FALSE);
get_monitor_for_rect (GdkDisplay *display,
const GdkRectangle *rect)
{
- gint biggest_area = G_MININT;
+ int biggest_area = G_MININT;
GdkMonitor *best_monitor = NULL;
GdkMonitor *monitor;
GdkRectangle workarea;
return best_monitor;
}
-static gint
+static int
get_anchor_x_sign (GdkGravity anchor)
{
switch (anchor)
}
}
-static gint
+static int
get_anchor_y_sign (GdkGravity anchor)
{
switch (anchor)
}
}
-static gint
-maybe_flip_position (gint bounds_pos,
- gint bounds_size,
- gint rect_pos,
- gint rect_size,
- gint surface_size,
- gint rect_sign,
- gint surface_sign,
- gint offset,
+static int
+maybe_flip_position (int bounds_pos,
+ int bounds_size,
+ int rect_pos,
+ int rect_size,
+ int surface_size,
+ int rect_sign,
+ int surface_sign,
+ int offset,
gboolean flip,
gboolean *flipped)
{
- gint primary;
- gint secondary;
+ int primary;
+ int secondary;
*flipped = FALSE;
primary = rect_pos + (1 + rect_sign) * rect_size / 2 + offset - (1 + surface_sign) * surface_size / 2;
**/
GdkSurface *
gdk_surface_new_toplevel (GdkDisplay *display,
- gint width,
- gint height)
+ int width,
+ int height)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
void
gdk_surface_constrain_size (GdkGeometry *geometry,
GdkSurfaceHints flags,
- gint width,
- gint height,
- gint *new_width,
- gint *new_height)
+ int width,
+ int height,
+ int *new_width,
+ int *new_height)
{
/* This routine is partially borrowed from fvwm.
*
*
* which in turn borrows parts of the algorithm from uwm
*/
- gint min_width = 0;
- gint min_height = 0;
- gint base_width = 0;
- gint base_height = 0;
- gint xinc = 1;
- gint yinc = 1;
- gint max_width = G_MAXINT;
- gint max_height = G_MAXINT;
+ int min_width = 0;
+ int min_height = 0;
+ int base_width = 0;
+ int base_height = 0;
+ int xinc = 1;
+ int yinc = 1;
+ int max_width = G_MAXINT;
+ int max_height = G_MAXINT;
-#define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
+#define FLOOR(value, base) ( ((int) ((value) / (base))) * (base) )
if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
{
geometry->min_aspect > 0 &&
geometry->max_aspect > 0)
{
- gint delta;
+ int delta;
if (flags & GDK_HINT_BASE_SIZE)
{
*/
void
gdk_surface_get_geometry (GdkSurface *surface,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+ int *x,
+ int *y,
+ int *width,
+ int *height)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
*/
void
gdk_surface_get_origin (GdkSurface *surface,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
*/
void
gdk_surface_get_root_coords (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y)
+ int x,
+ int y,
+ int *root_x,
+ int *root_y)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
*
* Returns: the scale factor
*/
-gint
+int
gdk_surface_get_scale_factor (GdkSurface *surface)
{
GdkSurfaceClass *class;
int *unscaled_height)
{
GdkSurfaceClass *class;
- gint scale;
+ int scale;
g_return_if_fail (GDK_IS_SURFACE (surface));
*/
void
gdk_surface_set_shadow_width (GdkSurface *surface,
- gint left,
- gint right,
- gint top,
- gint bottom)
+ int left,
+ int right,
+ int top,
+ int bottom)
{
GdkSurfaceClass *class;
double *y);
GDK_AVAILABLE_IN_ALL
-gint gdk_surface_get_scale_factor (GdkSurface *surface);
+int gdk_surface_get_scale_factor (GdkSurface *surface);
GDK_AVAILABLE_IN_ALL
void gdk_surface_get_device_position (GdkSurface *surface,
GDK_AVAILABLE_IN_ALL
void gdk_surface_set_shadow_width (GdkSurface *surface,
- gint left,
- gint right,
- gint top,
- gint bottom);
+ int left,
+ int right,
+ int top,
+ int bottom);
GDK_AVAILABLE_IN_ALL
GdkCairoContext *gdk_surface_create_cairo_context(GdkSurface *surface);
gpointer widget;
- gint x;
- gint y;
+ int x;
+ int y;
guint8 resize_count;
guint update_and_descendants_freeze_count;
- gint width, height;
- gint shadow_top;
- gint shadow_left;
- gint shadow_right;
- gint shadow_bottom;
+ int width, height;
+ int shadow_top;
+ int shadow_left;
+ int shadow_right;
+ int shadow_bottom;
GdkCursor *cursor;
GHashTable *device_cursor;
void (* hide) (GdkSurface *surface);
void (* get_geometry) (GdkSurface *surface,
- gint *x,
- gint *y,
- gint *width,
- gint *height);
+ int *x,
+ int *y,
+ int *width,
+ int *height);
void (* get_root_coords) (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y);
+ int x,
+ int y,
+ int *root_x,
+ int *root_y);
gboolean (* get_device_state) (GdkSurface *surface,
GdkDevice *device,
gdouble *x,
double dx,
double dy);
- gint (* get_scale_factor) (GdkSurface *surface);
+ int (* get_scale_factor) (GdkSurface *surface);
void (* get_unscaled_size) (GdkSurface *surface,
int *unscaled_width,
int *unscaled_height);
void (* set_opaque_region) (GdkSurface *surface,
cairo_region_t *region);
void (* set_shadow_width) (GdkSurface *surface,
- gint left,
- gint right,
- gint top,
- gint bottom);
+ int left,
+ int right,
+ int top,
+ int bottom);
GdkGLContext *(*create_gl_context) (GdkSurface *surface,
gboolean attached,
GdkGLContext *share,
*/
struct _GdkPoint
{
- gint x;
- gint y;
+ int x;
+ int y;
};
typedef struct _GdkPoint GdkPoint;
struct _GdkKeymapKey
{
guint keycode;
- gint group;
- gint level;
+ int group;
+ int level;
};
{
GdkMacosSurface *surface = gdk_surface;
NSRect rect;
- gint shadow_top;
+ int shadow_top;
/* Allow the window to move up "shadow_top" more than normally allowed
* by the default impl. This makes it possible to move windows with
static gboolean
gdk_display_link_source_prepare (GSource *source,
- gint *timeout_)
+ int *timeout_)
{
GdkDisplayLinkSource *impl = (GdkDisplayLinkSource *)source;
gint64 now;
GdkMacosDisplay *display;
GdkMacosSurface *surface;
NSPoint point;
- gint x;
- gint y;
+ int x;
+ int y;
g_assert (GDK_IS_MACOS_DEVICE (device));
g_assert (win_x != NULL);
settings->double_click_time = fval * 1000;
name = [[NSFont systemFontOfSize:0] familyName];
- pt_size = (gint)[[NSFont userFontOfSize:0] pointSize];
+ pt_size = (int)[[NSFont userFontOfSize:0] pointSize];
/* Let's try to use the "views" font size (12pt) by default. This is
* used for lists/text/other "content" which is the largest parts of
* apps, using the "regular control" size (13pt) looks a bit out of
static void
gdk_drag_get_current_actions (GdkModifierType state,
- gint button,
+ int button,
GdkDragAction actions,
GdkDragAction *suggested_action,
GdkDragAction *possible_actions)
GdkMacosDrag *self = GDK_MACOS_DRAG (drag);
GdkModifierType state;
GdkDevice *pointer;
- gint dx, dy;
+ int dx, dy;
dx = dy = 0;
state = gdk_event_get_modifier_state (event);
/* Between run_loop_before_waiting() and run_loop_after_waiting();
* max_prioritiy to pass to g_main_loop_check()
*/
-static gint run_loop_max_priority;
+static int run_loop_max_priority;
/* Timer that we've added to wake up the run loop when a GLib timeout
*/
* a run loop iteration, so we need to detect that and avoid triggering
* our "run the GLib main looop while the run loop is active machinery.
*/
-static gint getting_events = 0;
+static int getting_events = 0;
/************************************************************
********* Select Thread *********
static guint next_n_pollfds;
/* Pipe used to wake up the select thread */
-static gint select_thread_wakeup_pipe[2];
+static int select_thread_wakeup_pipe[2];
/* Run loop source used to wake up the main thread */
static CFRunLoopSourceRef select_main_thread_source;
guint nfds)
{
GString *s;
- gint i;
+ int i;
s = g_string_new ("");
for (i = 0; i < nfds; i++)
GPollFD *new_pollfds,
guint new_n_pollfds)
{
- gint i;
+ int i;
if (old_n_pollfds != new_n_pollfds)
return FALSE;
* 0: No file descriptors ready, asynchronous poll not needed
* > 0: Number of file descriptors ready
*/
-static gint
+static int
select_thread_start_poll (GPollFD *ufds,
guint nfds,
- gint timeout)
+ int timeout)
{
- gint n_ready;
+ int n_ready;
gboolean have_new_pollfds = FALSE;
- gint poll_fd_index = -1;
- gint i;
+ int poll_fd_index = -1;
+ int i;
for (i = 0; i < nfds; i++)
if (ufds[i].fd == -1)
static int
select_thread_collect_poll (GPollFD *ufds, guint nfds)
{
- gint i;
- gint n_ready = 0;
+ int i;
+ int n_ready = 0;
SELECT_THREAD_LOCK ();
static gboolean
gdk_macos_event_source_prepare (GSource *source,
- gint *timeout)
+ int *timeout)
{
GdkMacosEventSource *event_source = (GdkMacosEventSource *)source;
gboolean retval;
********* Our Poll Function *********
************************************************************/
-static gint
+static int
poll_func (GPollFD *ufds,
guint nfds,
- gint timeout_)
+ int timeout_)
{
NSEvent *event;
NSDate *limit_date;
- gint n_ready;
+ int n_ready;
static GPollFD *last_ufds;
/* Wrapper around g_main_context_query() that handles reallocating
* run_loop_pollfds up to the proper size
*/
-static gint
+static int
query_main_context (GMainContext *context,
int max_priority,
int *timeout)
{
- gint nfds;
+ int nfds;
if (!run_loop_pollfds)
{
run_loop_before_sources (void)
{
GMainContext *context = g_main_context_default ();
- gint max_priority;
- gint nfds;
+ int max_priority;
+ int nfds;
/* Before we let the CFRunLoop process sources, we want to check if there
* are any pending GLib main loop sources more urgent than
run_loop_before_waiting (void)
{
GMainContext *context = g_main_context_default ();
- gint timeout;
- gint n_ready;
+ int timeout;
+ int n_ready;
/* At this point, the CFRunLoop is ready to wait. We start a GMain loop
* iteration by calling the check() and query() stages. We start a
static guint
translate_keysym (guint hardware_keycode,
- gint group,
+ int group,
GdkModifierType state,
- gint *effective_group,
- gint *effective_level)
+ int *effective_group,
+ int *effective_level)
{
- gint level;
+ int level;
guint tmp_keyval;
level = (state & GDK_SHIFT_MASK) ? 1 : 0;
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries)
+ int *n_entries)
{
GArray *keys_array;
GArray *keyvals_array;
gdk_macos_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers)
{
guint tmp_keyval;
void _gdk_macos_surface_set_title (GdkMacosSurface *self,
const gchar *title);
void _gdk_macos_surface_get_shadow (GdkMacosSurface *self,
- gint *top,
- gint *right,
- gint *bottom,
- gint *left);
+ int *top,
+ int *right,
+ int *bottom,
+ int *left);
NSView *_gdk_macos_surface_get_view (GdkMacosSurface *self);
gboolean _gdk_macos_surface_get_modal_hint (GdkMacosSurface *self);
void _gdk_macos_surface_set_modal_hint (GdkMacosSurface *self,
_gdk_surface_clear_update_area (surface);
}
-static gint
+static int
gdk_macos_surface_get_scale_factor (GdkSurface *surface)
{
GdkMacosSurface *self = (GdkMacosSurface *)surface;
void
_gdk_macos_surface_get_shadow (GdkMacosSurface *self,
- gint *top,
- gint *right,
- gint *bottom,
- gint *left)
+ int *top,
+ int *right,
+ int *bottom,
+ int *left)
{
g_return_if_fail (GDK_IS_MACOS_SURFACE (self));
static const gchar *
name_fallback (const gchar *name)
{
- gint i;
+ int i;
for (i = 0; i < G_N_ELEMENTS (name_map); i++)
{
GdkWaylandTabletToolData *current_tool;
- gint axis_indices[GDK_AXIS_LAST];
+ int axis_indices[GDK_AXIS_LAST];
gdouble *axes;
};
_gdk_device_add_axis (device, GDK_AXIS_Y, 0, 0, 1);
}
-static gint
+static int
gdk_wayland_device_pad_get_n_groups (GdkDevicePad *pad)
{
GdkSeat *seat = gdk_device_get_seat (GDK_DEVICE (pad));
return g_list_length (data->mode_groups);
}
-static gint
+static int
gdk_wayland_device_pad_get_group_n_modes (GdkDevicePad *pad,
- gint n_group)
+ int n_group)
{
GdkSeat *seat = gdk_device_get_seat (GDK_DEVICE (pad));
GdkWaylandTabletPadGroupData *group;
return group->n_modes;
}
-static gint
+static int
gdk_wayland_device_pad_get_n_features (GdkDevicePad *pad,
GdkDevicePadFeature feature)
{
}
}
-static gint
+static int
gdk_wayland_device_pad_get_feature_group (GdkDevicePad *pad,
GdkDevicePadFeature feature,
- gint idx)
+ int idx)
{
GdkSeat *seat = gdk_device_get_seat (GDK_DEVICE (pad));
GdkWaylandTabletPadGroupData *group;
GdkWaylandTabletPadData *data;
GList *l;
- gint i;
+ int i;
data = gdk_wayland_seat_find_pad (GDK_WAYLAND_SEAT (seat),
GDK_DEVICE (pad));
gdk_wayland_device_tablet_clone_tool_axes (GdkWaylandTabletData *tablet,
GdkDeviceTool *tool)
{
- gint axis_pos;
+ int axis_pos;
g_object_freeze_notify (G_OBJECT (tablet->stylus_device));
_gdk_device_reset_axes (tablet->stylus_device);
{
gdouble axis_min, axis_max, axis_resolution;
GdkAxisUse axis_use;
- gint axis_count;
- gint i;
+ int axis_count;
+ int i;
g_object_freeze_notify (G_OBJECT (logical));
_gdk_device_reset_axes (logical);
{
GdkWaylandTabletToolData *tool = data;
GdkWaylandTabletData *tablet = tool->current_tablet;
- gint axis_index = tablet->axis_indices[GDK_AXIS_PRESSURE];
+ int axis_index = tablet->axis_indices[GDK_AXIS_PRESSURE];
_gdk_device_translate_axis (tablet->stylus_device, axis_index,
pressure, &tablet->axes[axis_index]);
{
GdkWaylandTabletToolData *tool = data;
GdkWaylandTabletData *tablet = tool->current_tablet;
- gint axis_index = tablet->axis_indices[GDK_AXIS_DISTANCE];
+ int axis_index = tablet->axis_indices[GDK_AXIS_DISTANCE];
_gdk_device_translate_axis (tablet->stylus_device, axis_index,
distance, &tablet->axes[axis_index]);
{
GdkWaylandTabletToolData *tool = data;
GdkWaylandTabletData *tablet = tool->current_tablet;
- gint xtilt_axis_index = tablet->axis_indices[GDK_AXIS_XTILT];
- gint ytilt_axis_index = tablet->axis_indices[GDK_AXIS_YTILT];
+ int xtilt_axis_index = tablet->axis_indices[GDK_AXIS_XTILT];
+ int ytilt_axis_index = tablet->axis_indices[GDK_AXIS_YTILT];
_gdk_device_translate_axis (tablet->stylus_device, xtilt_axis_index,
wl_fixed_to_double (xtilt),
{
GdkWaylandTabletToolData *tool = data;
GdkWaylandTabletData *tablet = tool->current_tablet;
- gint axis_index = tablet->axis_indices[GDK_AXIS_ROTATION];
+ int axis_index = tablet->axis_indices[GDK_AXIS_ROTATION];
_gdk_device_translate_axis (tablet->stylus_device, axis_index,
wl_fixed_to_double (degrees),
{
GdkWaylandTabletToolData *tool = data;
GdkWaylandTabletData *tablet = tool->current_tablet;
- gint axis_index = tablet->axis_indices[GDK_AXIS_SLIDER];
+ int axis_index = tablet->axis_indices[GDK_AXIS_SLIDER];
_gdk_device_translate_axis (tablet->stylus_device, axis_index,
position, &tablet->axes[axis_index]);
GdkWaylandTabletPadData *pad = data;
GdkWaylandTabletPadGroupData *group;
GdkEvent *event;
- gint n_group;
+ int n_group;
GDK_SEAT_NOTE (pad->seat, EVENTS,
g_message ("tablet pad handle button, pad = %p, button = %d, state = %d",
void
gdk_wayland_display_set_cursor_theme (GdkDisplay *display,
const gchar *name,
- gint size)
+ int size)
{
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY(display);
struct wl_cursor_theme *theme;
GType type;
union {
const char *s;
- gint i;
+ int i;
gboolean b;
} fallback;
};
GSettingsSchemaSource *source;
GSettingsSchema *schema;
GSettings *settings;
- gint i;
+ int i;
if (gdk_should_use_portal ())
{
typedef struct {
gboolean antialias;
gboolean hinting;
- gint dpi;
+ int dpi;
const gchar *rgba;
const gchar *hintstyle;
} GsdXftSettings;
struct wl_data_source *data_source;
struct wl_data_offer *offer;
uint32_t serial;
- gint hot_x;
- gint hot_y;
+ int hot_x;
+ int hot_y;
};
struct _GdkWaylandDragClass
static void
gdk_wayland_drag_set_hotspot (GdkDrag *drag,
- gint hot_x,
- gint hot_y)
+ int hot_x,
+ int hot_y)
{
GdkWaylandDrag *drag_wayland = GDK_WAYLAND_DRAG (drag);
- gint prev_hot_x = drag_wayland->hot_x;
- gint prev_hot_y = drag_wayland->hot_y;
+ int prev_hot_x = drag_wayland->hot_x;
+ int prev_hot_y = drag_wayland->hot_y;
const GdkRectangle damage_rect = { .width = 1, .height = 1 };
drag_wayland->hot_x = hot_x;
static gboolean
gdk_event_source_prepare (GSource *base,
- gint *timeout)
+ int *timeout)
{
GdkWaylandEventSource *source = (GdkWaylandEventSource *) base;
GdkWaylandDisplay *display = (GdkWaylandDisplay *) source->display;
gdk_wayland_keymap_get_direction (GdkKeymap *keymap)
{
GdkWaylandKeymap *keymap_wayland = GDK_WAYLAND_KEYMAP (keymap);
- gint i;
+ int i;
for (i = 0; i < xkb_keymap_num_layouts (keymap_wayland->xkb_keymap); i++)
{
max_keycode = xkb_keymap_max_keycode (xkb_keymap);
for (keycode = min_keycode; keycode < max_keycode; keycode++)
{
- gint num_layouts, layout;
+ int num_layouts, layout;
num_layouts = xkb_keymap_num_layouts_for_key (xkb_keymap, keycode);
for (layout = 0; layout < num_layouts; layout++)
{
- gint num_levels, level;
+ int num_levels, level;
num_levels = xkb_keymap_num_levels_for_key (xkb_keymap, keycode, layout);
for (level = 0; level < num_levels; level++)
{
const xkb_keysym_t *syms;
- gint num_syms, sym;
+ int num_syms, sym;
num_syms = xkb_keymap_key_get_syms_by_level (xkb_keymap, keycode, layout, level, &syms);
for (sym = 0; sym < num_syms; sym++)
{
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries)
+ int *n_entries)
{
struct xkb_keymap *xkb_keymap = GDK_WAYLAND_KEYMAP (keymap)->xkb_keymap;
- gint num_layouts, layout;
- gint num_entries;
- gint i;
+ int num_layouts, layout;
+ int num_entries;
+ int i;
num_layouts = xkb_keymap_num_layouts_for_key (xkb_keymap, hardware_keycode);
i = 0;
for (layout = 0; layout < num_layouts; layout++)
{
- gint num_levels, level;
+ int num_levels, level;
num_levels = xkb_keymap_num_levels_for_key (xkb_keymap, hardware_keycode, layout);
for (level = 0; level < num_levels; level++)
{
gdk_wayland_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *effective_level,
+ int *effective_group,
+ int *effective_level,
GdkModifierType *consumed_modifiers)
{
struct xkb_keymap *xkb_keymap;
static void
update_direction (GdkWaylandKeymap *keymap)
{
- gint num_layouts;
- gint i;
- gint *rtl;
+ int num_layouts;
+ int i;
+ int *rtl;
xkb_keycode_t min_keycode, max_keycode;
guint key;
gboolean have_rtl, have_ltr;
num_layouts = xkb_keymap_num_layouts (keymap->xkb_keymap);
keymap->direction = g_renew (PangoDirection, keymap->direction, num_layouts);
- rtl = g_newa (gint, num_layouts);
+ rtl = g_newa (int, num_layouts);
for (i = 0; i < num_layouts; i++)
rtl[i] = 0;
max_keycode = xkb_keymap_max_keycode (keymap->xkb_keymap);
for (key = min_keycode; key < max_keycode; key++)
{
- gint layouts, layout;
+ int layouts, layout;
layouts = xkb_keymap_num_layouts_for_key (keymap->xkb_keymap, key);
g_assert (layouts <= num_layouts);
for (layout = 0; layout < layouts; layout++)
{
const xkb_keysym_t *syms;
- gint num_syms;
- gint sym;
+ int num_syms;
+ int sym;
num_syms = xkb_keymap_key_get_syms_by_level (keymap->xkb_keymap, key, layout, 0, &syms);
for (sym = 0; sym < num_syms; sym++)
static void unset_transient_for_exported (GdkSurface *surface);
static void gdk_wayland_surface_move_resize (GdkSurface *surface,
- gint x,
- gint y,
- gint width,
- gint height);
+ int x,
+ int y,
+ int width,
+ int height);
static void update_popup_layout_state (GdkSurface *surface,
int x,
int height,
GdkPopupLayout *layout)
{
- gint surface_x, surface_y;
- gint surface_width, surface_height;
+ int surface_x, surface_y;
+ int surface_width, surface_height;
GdkRectangle best_rect;
GdkRectangle flipped_rect;
GdkGravity rect_anchor;
GdkRectangle geometry;
uint32_t constraint_adjustment = ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_NONE;
const GdkRectangle *anchor_rect;
- gint real_anchor_rect_x, real_anchor_rect_y;
- gint anchor_rect_width, anchor_rect_height;
+ int real_anchor_rect_x, real_anchor_rect_y;
+ int anchor_rect_width, anchor_rect_height;
int rect_anchor_dx;
int rect_anchor_dy;
GdkGravity rect_anchor;
static void
gdk_wayland_surface_move_resize (GdkSurface *surface,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
static void
gdk_wayland_surface_get_geometry (GdkSurface *surface,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+ int *x,
+ int *y,
+ int *width,
+ int *height)
{
if (!GDK_SURFACE_DESTROYED (surface))
{
static void
gdk_wayland_surface_get_root_coords (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y)
+ int x,
+ int y,
+ int *root_x,
+ int *root_y)
{
/*
* Wayland does not have a global coordinate space shared between surfaces. In
g_object_unref (surface);
}
-static gint
+static int
gdk_wayland_surface_get_scale_factor (GdkSurface *surface)
{
GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
int bottom)
{
GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
- gint new_width, new_height;
+ int new_width, new_height;
if (GDK_SURFACE_DESTROYED (surface))
return;
GDK_AVAILABLE_IN_ALL
void gdk_wayland_display_set_cursor_theme (GdkDisplay *display,
const gchar *theme,
- gint size);
+ int size);
GDK_AVAILABLE_IN_ALL
const gchar * gdk_wayland_display_get_startup_notification_id (GdkDisplay *display);
GDK_AVAILABLE_IN_ALL
typedef struct {
gchar *name;
- gint id;
+ int id;
gchar *bitmap;
- gint hotx;
- gint hoty;
+ int hotx;
+ int hoty;
} font_info_t;
typedef struct {
gchar *name;
- gint id;
- gint width;
- gint height;
- gint hotx;
- gint hoty;
+ int id;
+ int width;
+ int height;
+ int hotx;
+ int hoty;
gchar *data;
} cursor_info_t;
static GSList *fonts = NULL;
static GSList *cursors = NULL;
-static gint dw,dh;
+static int dw,dh;
static gboolean debug = FALSE;
}
}
-static gint read_bdf_font(fname)
+static int read_bdf_font(fname)
gchar *fname;
{
FILE *f;
gchar line[2048];
- gint rv = 0;
+ int rv = 0;
gboolean startchar = FALSE, startbitmap = FALSE;
gchar *charname,*p,*bitmap;
- gint dx = 0,dy = 0;
- gint w,h,x,y,py;
- gint id,tmp;
+ int dx = 0,dy = 0;
+ int w,h,x,y,py;
+ int id,tmp;
dw = 0;
dh = 0;
return rv;
}
-static gint font_info_compare(fi, name)
+static int font_info_compare(fi, name)
font_info_t *fi;
char *name;
{
{
static gchar cdata[8192];
gchar *p;
- gint i;
- gint c;
+ int i;
+ int c;
gboolean flushed;
sprintf(cdata, " { \"%s\", %d, %d, %d, %d, %d, \n \"",
GSList *ptr;
FILE *f = stdout;
- fprintf(f, "static const struct { const gchar *name; gint type; guchar width; guchar height; guchar hotx; guchar hoty; guchar *data; } cursors[] = {\n");
+ fprintf(f, "static const struct { const gchar *name; int type; guchar width; guchar height; guchar hotx; guchar hoty; guchar *data; } cursors[] = {\n");
for (ptr = cursors; ptr; ptr = ptr->next)
{
return 0;
}
-gint main(argc, argv)
-gint argc;
+int main(argc, argv)
+int argc;
gchar **argv;
{
if (argc != 2)
void
gdk_win32_surface_get_queued_window_rect (GdkSurface *surface,
- gint scale,
+ int scale,
RECT *return_window_rect)
{
RECT window_rect;
static cairo_surface_t *
create_cairo_surface_for_layered_window (GdkWin32Surface *impl,
- gint width,
- gint height,
- gint scale)
+ int width,
+ int height,
+ int scale)
{
if (width > impl->dib_width ||
height > impl->dib_height)
GdkWin32Surface *impl;
int scale;
cairo_t *cr;
- gint width, height;
+ int width, height;
RECT queued_window_rect;
surface = gdk_draw_context_get_surface (draw_context);
{
GdkWin32CairoContext *self = GDK_WIN32_CAIRO_CONTEXT (draw_context);
GdkSurface *surface;
- gint scale;
+ int scale;
surface = gdk_draw_context_get_surface (draw_context);
scale = gdk_surface_get_scale_factor (surface);
* around between repaints, and only re-allocate it
* if it's too small. */
cairo_surface_t *db_surface;
- gint db_width;
- gint db_height;
+ int db_width;
+ int db_height;
/* Surface for the window DC (in non-layered mode).
* A reference of the cache surface (in layered mode). */
GdkWin32ClipboardThreadAdvertise *adv;
GdkWin32ClipboardThreadRetrieve *retr;
GdkWin32ClipboardThreadStore *store;
- gint i;
+ int i;
switch (item->item_type)
{
process_advertise (GdkWin32ClipboardThreadAdvertise *adv)
{
DWORD error_code;
- gint i;
+ int i;
if (g_get_monotonic_time () > adv->parent.end_time)
{
process_store (GdkWin32ClipboardThreadStore *store)
{
DWORD error_code;
- gint i;
+ int i;
if (g_get_monotonic_time () > store->parent.end_time)
{
process_retrieve (GdkWin32ClipboardThreadRetrieve *retr)
{
DWORD error_code;
- gint i;
+ int i;
UINT fmt, fmt_to_use;
HANDLE hdata;
GdkWin32ContentFormatPair *pair;
if (API_CALL (OpenClipboard, (hwnd)))
{
- gint i;
+ int i;
GdkWin32ContentFormatPair *pair;
for (pair = NULL, i = 0;
}
case WM_RENDERFORMAT:
{
- gint i;
+ int i;
GdkWin32ClipboardThreadRender *render;
GdkWin32ClipboardThreadRender *returned_render;
GdkWin32ContentFormatPair *pair;
_gdk_win32_get_clipboard_format_name (UINT fmt,
gboolean *is_predefined)
{
- gint registered_name_w_len = 1024;
+ int registered_name_w_len = 1024;
wchar_t *registered_name_w = g_malloc (registered_name_w_len);
gchar *registered_name = NULL;
int gcfn_result;
get_compatibility_w32formats_for_contentformat (const gchar *contentformat)
{
GArray *result = NULL;
- gint i;
+ int i;
GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
result = g_hash_table_lookup (clipdrop->compatibility_w32formats, contentformat);
const gchar *interned_w32format_name;
GdkWin32ContentFormatPair pair;
GArray *comp_pairs;
- gint i, j;
+ int i, j;
if (w32format_name != NULL)
{
static void
transmute_cf_unicodetext_to_utf8_string (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
static void
transmute_utf8_string_to_cf_unicodetext (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
glong wclen;
GError *err = NULL;
glong size;
- gint i;
+ int i;
wchar_t *wcptr, *p;
wcptr = g_utf8_to_utf16 ((char *) data, length, NULL, &wclen, &err);
static void
transmute_utf8_string_to_cf_text (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
glong rlen;
GError *err = NULL;
gsize size;
- gint i;
+ int i;
char *strptr, *p;
wchar_t *wcptr;
static void
transmute_cf_text_to_utf8_string (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
static void
transmute_cf_dib_to_image_bmp (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
BITMAPINFOHEADER *bi = (BITMAPINFOHEADER *) data;
BITMAPFILEHEADER *bf;
gpointer result;
- gint data_length = length;
- gint new_length;
+ int data_length = length;
+ int new_length;
gboolean make_dibv5 = FALSE;
BITMAPV5HEADER *bV5;
guchar *p;
static void
transmute_cf_shell_id_list_to_text_uri_list (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
void
transmute_image_bmp_to_cf_dib (const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length,
GDestroyNotify *set_data_destroy)
{
- gint size;
+ int size;
guchar *ptr;
g_return_if_fail (length >= sizeof (BITMAPFILEHEADER));
_gdk_win32_transmute_contentformat (const gchar *from_contentformat,
UINT to_w32format,
const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length)
{
return TRUE;
}
-gint
+int
_gdk_win32_add_contentformat_to_pairs (const char *contentformat,
GArray *array)
{
- gint added_count = 0;
+ int added_count = 0;
wchar_t *contentformat_w;
GdkWin32ContentFormatPair fmt;
- gint i;
+ int i;
GArray *comp_pairs;
- gint starting_point;
+ int starting_point;
const wchar_t *prefix = L"application/x.windows.";
size_t prefix_len = wcslen (prefix);
size_t offset = 0;
comp_pairs = get_compatibility_w32formats_for_contentformat (contentformat);
for (i = 0; comp_pairs != NULL && i < comp_pairs->len; i++)
{
- gint j;
+ int j;
fmt = g_array_index (comp_pairs, GdkWin32ContentFormatPair, i);
gpointer user_data)
{
GError *error = NULL;
- gint i;
+ int i;
gboolean no_other_streams;
GdkWin32ClipboardHDataPrepAndStream *prep_and_stream = (GdkWin32ClipboardHDataPrepAndStream *) user_data;
GdkWin32ClipboardStorePrep *prep = prep_and_stream->prep;
* Also remembers whether the data needs to be transmuted.
*/
typedef struct {
- gint w32format;
+ int w32format;
/* This is assumed to be an interned string, it will be
* compared by simply comparing the pointer.
*/
* anything in the queue. If there is, then the queue
* processing (which requires expensice locks) can happen.
*/
- gint dnd_queue_counter;
+ int dnd_queue_counter;
/* We don't actually support multiple simultaneous drags,
* for obvious reasons (though this might change with
void _gdk_win32_add_w32format_to_pairs (UINT format,
GArray *array,
GdkContentFormatsBuilder *builder);
-gint _gdk_win32_add_contentformat_to_pairs (const char *target,
+int _gdk_win32_add_contentformat_to_pairs (const char *target,
GArray *array);
void _gdk_win32_clipboard_default_output_done (GObject *clipboard,
gboolean _gdk_win32_transmute_contentformat (const gchar *from_contentformat,
UINT to_w32format,
const guchar *data,
- gint length,
+ int length,
guchar **set_data,
gsize *set_data_length);
}
static HCURSOR
-hcursor_from_x_cursor (gint i,
+hcursor_from_x_cursor (int i,
const gchar *name)
{
- gint j, x, y, ofs;
+ int j, x, y, ofs;
HCURSOR rv;
- gint w, h;
+ int w, h;
guchar *and_plane, *xor_plane;
w = GetSystemMetrics (SM_CXCURSOR);
for (x = 0; x < cursors[i].width && x < w ; x++, j++)
{
- gint pofs = ofs + x / 8;
+ int pofs = ofs + x / 8;
guchar data = (cursors[i].data[j/4] & (0xc0 >> (2 * (j%4)))) >> (2 * (3 - (j%4)));
- gint bit = 7 - (j % cursors[i].width) % 8;
+ int bit = 7 - (j % cursors[i].width) % 8;
if (data)
{
static Win32Cursor *
win32_cursor_new (GdkWin32CursorLoadType load_type,
gpointer resource_name,
- gint width,
- gint height,
+ int width,
+ int height,
guint load_flags,
- gint xcursor_number)
+ int xcursor_number)
{
Win32Cursor *result;
static void
win32_cursor_theme_load_from (Win32CursorTheme *theme,
- gint size,
+ int size,
const gchar *dir)
{
GDir *gdir;
static void
win32_cursor_theme_load_from_dirs (Win32CursorTheme *theme,
const gchar *name,
- gint size)
+ int size)
{
gchar *theme_dir;
const gchar * const *dirs;
- gint i;
+ int i;
dirs = g_get_system_data_dirs ();
static void
win32_cursor_theme_load_system (Win32CursorTheme *theme,
- gint size)
+ int size)
{
- gint i;
+ int i;
HCURSOR shared_hcursor;
HCURSOR x_hcursor;
Win32Cursor *cursor;
Win32CursorTheme *
win32_cursor_theme_load (const gchar *name,
- gint size)
+ int size)
{
Win32CursorTheme *result = g_new0 (Win32CursorTheme, 1);
win32hcursor_x_from_name (GdkWin32Display *display,
const gchar *name)
{
- gint i;
+ int i;
for (i = 0; i < G_N_ELEMENTS (cursors); i++)
if (cursors[i].name == NULL || strcmp (cursors[i].name, name) == 0)
static GdkWin32HCursor *
create_blank_win32hcursor (GdkWin32Display *display)
{
- gint w, h;
+ int w, h;
guchar *and_plane, *xor_plane;
HCURSOR rv;
static HICON
pixbuf_to_hicon (GdkPixbuf *pixbuf,
gboolean is_icon,
- gint x,
- gint y);
+ int x,
+ int y);
static GdkWin32HCursor *
gdk_win32hcursor_create_for_texture (GdkWin32Display *display,
{
cairo_surface_t *surface;
GdkPixbuf *pixbuf;
- gint width, height;
+ int width, height;
HICON icon;
surface = gdk_texture_download_surface (texture);
} bmi;
HDC hdc;
guchar *pixels, *bits;
- gint rowstride, x, y, w, h;
+ int rowstride, x, y, w, h;
if (!GDI_CALL (GetIconInfo, (hicon, &ii)))
return NULL;
{
for (x = 0; x < w; x++)
{
- const gint bit = 7 - (x % 8);
+ const int bit = 7 - (x % 8);
printf ("%c ", ((bits[bpl*y+x/8])&(1<<bit)) ? ' ' : 'X');
}
printf ("\n");
}
for (x = 0; x < w; x++)
{
- const gint bit = 7 - (x % 8);
+ const int bit = 7 - (x % 8);
if ((*andp) & (1<<bit))
{
if ((*xorp) & (1<<bit))
*/
static HBITMAP
-create_alpha_bitmap (gint size,
+create_alpha_bitmap (int size,
guchar **outdata)
{
BITMAPV5HEADER bi;
}
static HBITMAP
-create_color_bitmap (gint size,
+create_color_bitmap (int size,
guchar **outdata,
- gint bits)
+ int bits)
{
struct {
BITMAPV4HEADER bmiHeader;
HBITMAP hColorBitmap, hMaskBitmap;
guchar *indata, *inrow;
guchar *colordata, *colorrow, *maskdata, *maskbyte;
- gint width, height, size, i, i_offset, j, j_offset, rowstride;
+ int width, height, size, i, i_offset, j, j_offset, rowstride;
guint maskstride, mask_bit;
width = gdk_pixbuf_get_width (pixbuf); /* width of icon */
HBITMAP hColorBitmap, hMaskBitmap;
guchar *indata, *inrow;
guchar *colordata, *colorrow, *maskdata, *maskbyte;
- gint width, height, size, i, i_offset, j, j_offset, rowstride, nc, bmstride;
+ int width, height, size, i, i_offset, j, j_offset, rowstride, nc, bmstride;
gboolean has_alpha;
guint maskstride, mask_bit;
static HICON
pixbuf_to_hicon (GdkPixbuf *pixbuf,
gboolean is_icon,
- gint x,
- gint y)
+ int x,
+ int y)
{
ICONINFO ii;
HICON icon;
{
cairo_surface_t *surface;
GdkPixbuf *pixbuf;
- gint width, height;
+ int width, height;
HICON icon;
surface = gdk_texture_download_surface (texture);
HICON
_gdk_win32_pixbuf_to_hcursor (GdkPixbuf *pixbuf,
- gint x_hotspot,
- gint y_hotspot)
+ int x_hotspot,
+ int y_hotspot)
{
return pixbuf_to_hicon (pixbuf, FALSE, x_hotspot, y_hotspot);
}
{
POINT point;
HWND hwnd, hwndc;
- gint scale;
+ int scale;
if (window)
{
{
GdkDevice *device;
GdkSurface *impl_surface;
- gint root_x, root_y;
+ int root_x, root_y;
gdouble temp_x, temp_y;
- gint i;
+ int i;
device = GDK_DEVICE (device_wintab);
impl_surface = window;
GdkDevice parent_instance;
gboolean sends_core;
- gint *last_axis_data;
- gint button_state;
+ int *last_axis_data;
+ int button_state;
/* WINTAB stuff: */
HCTX hctx;
static GList *wintab_contexts = NULL;
static GdkSurface *wintab_window = NULL;
-extern gint _gdk_input_ignore_core;
+extern int _gdk_input_ignore_core;
typedef UINT (WINAPI *t_WTInfoA) (UINT a, UINT b, LPVOID c);
typedef UINT (WINAPI *t_WTInfoW) (UINT a, UINT b, LPVOID c);
num_axes += 2;
}
- device->last_axis_data = g_new (gint, num_axes);
+ device->last_axis_data = g_new (int, num_axes);
GDK_NOTE (INPUT, g_print ("device: (%u) %s axes: %d\n",
cursorix,
}
static void
-decode_tilt (gint *axis_data,
+decode_tilt (int *axis_data,
AXIS *axes,
PACKET *packet)
{
GdkEvent *event;
PACKET packet;
- gint num_axes;
+ int num_axes;
double x, y;
guint translated_buttons, button_diff, button_mask;
* of our context (WT_PROXIMITY). Bumped down when we either
* receive a WT_PACKET, or a WT_CSRCHANGE.
*/
- gint dev_entered_proximity;
+ int dev_entered_proximity;
};
struct _GdkDeviceManagerWin32Class
_gdk_win32_display_init_monitors (GdkWin32Display *win32_display)
{
GPtrArray *new_monitors;
- gint i;
+ int i;
GdkWin32Monitor *primary_to_move = NULL;
for (i = 0; i < g_list_model_get_n_items (win32_display->monitors); i++)
void
gdk_win32_display_set_cursor_theme (GdkDisplay *display,
const gchar *name,
- gint size)
+ int size)
{
- gint cursor_size;
- gint w, h;
+ int cursor_size;
+ int w, h;
Win32CursorTheme *theme;
GdkWin32Display *win32_display = GDK_WIN32_DISPLAY (display);
_gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *win32_display,
HMONITOR hmonitor,
HWND hwnd,
- gint *dpi)
+ int *dpi)
{
gboolean is_scale_acquired = FALSE;
gboolean use_dpi_for_monitor = FALSE;
guint _gdk_win32_display_get_monitor_scale_factor (GdkWin32Display *win32_display,
HMONITOR hmonitor,
HWND hwnd,
- gint *dpi);
+ int *dpi);
typedef struct _GdkWin32MessageFilter GdkWin32MessageFilter;
{
IDropSource ids;
IDropSourceNotify idsn;
- gint ref_count;
+ int ref_count;
GdkDrag *drag;
/* These are thread-local
GdkWin32ContentFormatPair **pair)
{
data_object *ctx = (data_object *) This;
- gint i;
+ int i;
if (pair)
*pair = NULL;
for (i = 0; i < n_mime_types; i++)
{
- gint added_count = 0;
- gint j;
+ int added_count = 0;
+ int j;
GDK_NOTE (DND, g_print ("DataObject supports contentformat 0x%p (%s)\n", mime_types[i], mime_types[i]));
* Unless, of course, we keep the LOCAL protocol around.
*/
typedef struct {
- gint x;
- gint y;
+ int x;
+ int y;
HWND ignore;
HWND result;
} find_window_enum_arg;
static HWND
gdk_win32_drag_find_window (GdkDrag *drag,
GdkSurface *drag_surface,
- gint x_root,
- gint y_root)
+ int x_root,
+ int y_root)
{
GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
find_window_enum_arg a;
static gboolean
gdk_win32_local_drag_motion (GdkDrag *drag,
HWND dest_window,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
GdkDragAction possible_actions,
DWORD key_state,
guint32 time_)
gint64 current_time;
double f;
double t;
- gint x, y;
+ int x, y;
if (!frame_clock)
return G_SOURCE_REMOVE;
GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
GdkModifierType state;
GdkDevice *pointer;
- gint dx, dy;
+ int dx, dy;
GDK_NOTE (DND, g_print ("gdk_dnd_handle_key_event: 0x%p\n", drag));
static void
gdk_win32_drag_set_hotspot (GdkDrag *drag,
- gint hot_x,
- gint hot_y)
+ int hot_x,
+ int hot_y)
{
GdkWin32Drag *drag_win32 = GDK_WIN32_DRAG (drag);
GdkDragAction actions;
guint scale; /* Temporarily caches the HiDPI scale */
- gint last_x; /* Coordinates from last event, in GDK space */
- gint last_y;
+ int last_x; /* Coordinates from last event, in GDK space */
+ int last_y;
DWORD last_key_state; /* Key state from last event */
/* Just like GdkDrop->formats, but an array, and with format IDs
struct _drop_target_context
{
IDropTarget idt;
- gint ref_count;
+ int ref_count;
/* The drop object we create when a drag enters our surface.
* The drop object is destroyed when the drag leaves.
void
_gdk_win32_local_drop_target_dragenter (GdkDrag *drag,
GdkSurface *dest_surface,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
DWORD grfKeyState,
guint32 time_,
GdkDragAction *actions)
GdkDrop *drop;
GdkWin32Drop *drop_win32;
GdkDisplay *display;
- gint pt_x;
- gint pt_y;
+ int pt_x;
+ int pt_y;
GdkDrag *drag;
GdkDragAction source_actions;
GdkDragAction dest_actions;
gboolean
_gdk_win32_local_drop_target_will_emit_motion (GdkDrop *drop,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
DWORD grfKeyState)
{
GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (drop);
void
_gdk_win32_local_drop_target_dragover (GdkDrop *drop,
GdkDrag *drag,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
DWORD grfKeyState,
guint32 time_,
GdkDragAction *actions)
{
drop_target_context *ctx = (drop_target_context *) This;
GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (ctx->drop);
- gint pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
- gint pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
+ int pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
+ int pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
GdkDragAction source_actions;
GdkDragAction dest_actions;
{
drop_target_context *ctx = (drop_target_context *) This;
GdkWin32Drop *drop_win32 = GDK_WIN32_DROP (ctx->drop);
- gint pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
- gint pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
+ int pt_x = pt.x / drop_win32->scale + _gdk_offset_x;
+ int pt_y = pt.y / drop_win32->scale + _gdk_offset_y;
GdkDragAction dest_action;
GDK_NOTE (DND, g_print ("idroptarget_drop %p ", This));
static GdkWin32MessageFilterReturn
gdk_dropfiles_filter (GdkWin32Display *display,
MSG *msg,
- gint *ret_valp,
+ int *ret_valp,
gpointer data)
{
GdkSurface *window;
GString *result;
HANDLE hdrop;
POINT pt;
- gint nfiles, i;
+ int nfiles, i;
gchar *fileName, *linkedFile;
if (msg->message != WM_DROPFILES)
#define SYNAPSIS_ICON_WINDOW_CLASS "SynTrackCursorWindowClass"
static gboolean gdk_event_translate (MSG *msg,
- gint *ret_valp);
+ int *ret_valp);
static gboolean gdk_event_prepare (GSource *source,
- gint *timeout);
+ int *timeout);
static gboolean gdk_event_check (GSource *source);
static gboolean gdk_event_dispatch (GSource *source,
GSourceFunc callback,
/* Private variable declarations
*/
-extern gint _gdk_input_ignore_core;
+extern int _gdk_input_ignore_core;
typedef struct
{
static GdkSurface *mouse_window = NULL;
static GdkSurface *mouse_window_ignored_leave = NULL;
-static gint current_x, current_y;
-static gint current_root_x, current_root_y;
+static int current_x, current_y;
+static int current_root_x, current_root_y;
static UINT got_gdk_events_message;
static HWND modal_win32_dialog = NULL;
{
MSG msg;
DWORD pos;
- gint ret_val = 0;
+ int ret_val = 0;
msg.hwnd = hwnd;
msg.message = message;
return _gdk_win32_keymap_get_active_group (keymap);
}
-static gint
+static int
build_pointer_event_state (MSG *msg)
{
- gint state;
+ int state;
state = 0;
static GdkWin32MessageFilterReturn
apply_message_filters (GdkDisplay *display,
MSG *msg,
- gint *ret_valp,
+ int *ret_valp,
GList **filters)
{
GdkWin32MessageFilterReturn result = GDK_WIN32_MESSAGE_FILTER_CONTINUE;
RGNDATA *rgndata;
RECT *rects;
cairo_region_t *result;
- gint nbytes;
+ int nbytes;
guint i;
if ((nbytes = GetRegionData (hrgn, 0, NULL)) == 0)
static void
adjust_drag (LONG *drag,
LONG curr,
- gint inc)
+ int inc)
{
if (*drag > curr)
*drag = curr + ((*drag + inc/2 - curr) / inc) * inc;
GdkSurface *window,
gint16 screen_x,
gint16 screen_y,
- gint *ret_valp)
+ int *ret_valp)
{
RECT rect;
GdkWin32Surface *impl;
static void
generate_button_event (GdkEventType type,
- gint button,
+ int button,
GdkSurface *window,
MSG *msg)
{
}
static gboolean
-handle_wm_sysmenu (GdkSurface *window, MSG *msg, gint *ret_valp)
+handle_wm_sysmenu (GdkSurface *window, MSG *msg, int *ret_valp)
{
GdkWin32Surface *impl;
LONG_PTR style, tmp_style;
GDK_BUTTON5_MASK)
static gboolean
-gdk_event_translate (MSG *msg,
- gint *ret_valp)
+gdk_event_translate (MSG *msg,
+ int *ret_valp)
{
RECT rect, *drag, orig_drag;
POINT point;
GdkEvent *event;
wchar_t wbuf[100];
- gint ccount;
+ int ccount;
GdkDisplay *display;
GdkSurface *window = NULL;
GdkDeviceGrabInfo *pointer_grab = NULL;
GdkSurface *grab_window = NULL;
- gint button;
+ int button;
gchar buf[256];
gboolean return_val = FALSE;
{
if (both_shift_pressed[0] != 0 && both_shift_pressed[1] != 0)
{
- gint tmp_retval;
+ int tmp_retval;
MSG fake_release = *msg;
int pressed_shift = msg->lParam & 0xffffff;
if (pointer_grab == NULL && implicit_grab_surface != NULL)
{
- gint state = build_pointer_event_state (msg);
+ int state = build_pointer_event_state (msg);
/* We keep the implicit grab until no buttons at all are held down */
if ((state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (button - 1))) == 0)
static gboolean
gdk_event_prepare (GSource *source,
- gint *timeout)
+ int *timeout)
{
GdkWin32EventSource *event_source = (GdkWin32EventSource *)source;
gboolean retval;
NULL);
}
-static gint
+static int
_gdk_init_dummy_context (GdkWGLDummy *dummy);
#define PIXEL_ATTRIBUTES 17
-static gint
+static int
_get_wgl_pfd (HDC hdc,
PIXELFORMATDESCRIPTOR *pfd,
GdkWin32Display *display)
{
- gint best_pf = 0;
+ int best_pf = 0;
pfd->nSize = sizeof (PIXELFORMATDESCRIPTOR);
{
GdkWGLDummy dummy;
UINT num_formats;
- gint colorbits = GetDeviceCaps (hdc, BITSPIXEL);
+ int colorbits = GetDeviceCaps (hdc, BITSPIXEL);
guint extra_fields = 1;
- gint i = 0;
+ int i = 0;
int pixelAttribs[PIXEL_ATTRIBUTES];
/* Save up the HDC and HGLRC that we are currently using, to restore back to it when we are done here */
/* in WGL, for many OpenGL items, we need a dummy WGL context, so create
* one and cache it for later use
*/
-static gint
+static int
_gdk_init_dummy_context (GdkWGLDummy *dummy)
{
PIXELFORMATDESCRIPTOR pfd;
gboolean set_pixel_format_result = FALSE;
- gint best_idx = 0;
+ int best_idx = 0;
_get_dummy_window_hwnd (dummy);
_gdk_win32_display_init_gl (GdkDisplay *display)
{
GdkWin32Display *display_win32 = GDK_WIN32_DISPLAY (display);
- gint best_idx = 0;
+ int best_idx = 0;
GdkWGLDummy dummy;
if (display_win32->have_wgl)
static gboolean
_set_pixformat_for_hdc (HDC hdc,
- gint *best_idx,
+ int *best_idx,
GdkWin32Display *display)
{
PIXELFORMATDESCRIPTOR pfd;
/* These are the real WGL context items that we will want to use later */
HGLRC hglrc;
- gint pixel_format;
+ int pixel_format;
gboolean debug_bit, compat_bit, legacy_bit;
/* request flags and specific versions for core (3.2+) WGL context */
- gint flags = 0;
- gint glver_major = 0;
- gint glver_minor = 0;
+ int flags = 0;
+ int glver_major = 0;
+ int glver_minor = 0;
GdkSurface *surface = gdk_gl_context_get_surface (context);
GdkWin32Surface *impl = GDK_WIN32_SURFACE (surface);
*/
gboolean
gdk_win32_display_get_wgl_version (GdkDisplay *display,
- gint *major,
- gint *minor)
+ int *major,
+ int *minor)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
GdkDisplay *_gdk_display = NULL;
GdkDeviceManagerWin32 *_gdk_device_manager = NULL;
-gint _gdk_offset_x, _gdk_offset_y;
+int _gdk_offset_x, _gdk_offset_y;
HDC _gdk_display_hdc;
HINSTANCE _gdk_dll_hinstance;
HINSTANCE _gdk_app_hmodule;
-gint _gdk_input_ignore_core;
+int _gdk_input_ignore_core;
HKL _gdk_input_locale;
gboolean _gdk_input_locale_is_ime = FALSE;
UINT _gdk_input_codepage;
-gint _gdk_input_ignore_wintab = FALSE;
-gint _gdk_max_colors = 0;
+int _gdk_input_ignore_wintab = FALSE;
+int _gdk_max_colors = 0;
GdkWin32ModalOpKind _modal_operation_in_progress = GDK_WIN32_MODAL_OP_NONE;
HWND _modal_move_resize_window = NULL;
/* The singleton clipdrop object pointer */
GdkWin32Clipdrop *_win32_clipdrop = NULL;
-GThread *_win32_main_thread = NULL;
\ No newline at end of file
+GThread *_win32_main_thread = NULL;
static void
print_keysym_tab (GdkWin32Keymap *keymap)
{
- gint li;
+ int li;
GdkWin32KeyGroupOptions *options;
- gint vk;
+ int vk;
GdkWin32KeyLevelState level;
- gint group_size = keymap->layout_handles->len;
+ int group_size = keymap->layout_handles->len;
for (li = 0; li < group_size; li++)
{
static void
handle_special (guint vk,
guint *ksymp,
- gint shift)
+ int shift)
{
switch (vk)
}
static gboolean
-layouts_are_the_same (GArray *array, HKL *hkls, gint hkls_len)
+layouts_are_the_same (GArray *array, HKL *hkls, int hkls_len)
{
- gint i;
+ int i;
if (hkls_len != array->len)
return FALSE;
}
}
-static gint
+static int
sort_key_nodes_by_gdk_keyval (gconstpointer a,
gconstpointer b)
{
static HKL *hkls = NULL;
gboolean no_list;
static guint current_serial = 0;
- gint i, group;
+ int i, group;
GdkWin32KeyLevelState level;
GdkWin32KeyGroupOptions *options;
GdkWin32Keymap *keymap = GDK_WIN32_KEYMAP (gdk_keymap);
- gint keysym_tab_size;
+ int keysym_tab_size;
guchar key_state[KEY_STATE_SIZE];
guint scancode;
((vk == VK_DECIMAL) && (level == GDK_WIN32_LEVEL_NONE)))
{
wchar_t wcs[10];
- gint k;
+ int k;
guint keysym;
GdkWin32KeyNode dead_key;
for (i = 0; i < options->dead_keys->len; i++)
{
wchar_t wcs[10];
- gint k;
+ int k;
GdkWin32KeyNode *dead_key;
GdkWin32KeyNode combo;
guint16 *output,
gsize *output_len)
{
- gint partial_match;
+ int partial_match;
guint8 active_group;
gsize deadkey_i, node_i;
GdkWin32KeyNode *dead_key;
if (keymap != NULL &&
keymap->layout_handles->len > 0)
{
- gint group;
+ int group;
for (group = 0; group < keymap->layout_handles->len; group++)
if (g_array_index (keymap->layout_handles, HKL, group) == hkl)
GdkWin32Keymap *keymap;
gboolean have_rtl = FALSE;
gboolean have_ltr = FALSE;
- gint group;
+ int group;
GdkKeymap *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
if (gdk_keymap == NULL || gdk_keymap != default_keymap)
/* Accept only the default keymap */
if (gdk_keymap == NULL || gdk_keymap == default_keymap)
{
- gint vk;
+ int vk;
GdkWin32Keymap *keymap;
if (gdk_keymap == NULL)
for (vk = 0; vk < KEY_STATE_SIZE; vk++)
{
- gint group;
+ int group;
for (group = 0; group < keymap->layout_handles->len; group++)
{
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries)
+ int *n_entries)
{
GArray *key_array;
GArray *keyval_array;
- gint group;
+ int group;
GdkWin32Keymap *keymap;
GdkKeymap *default_keymap = gdk_display_get_keymap (gdk_display_get_default ());
gdk_win32_keymap_translate_keyboard_state (GdkKeymap *gdk_keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers)
{
GdkWin32Keymap *keymap;
g_free (pe);
}
-static gint
+static int
palette_size (HPALETTE hpal)
{
WORD npal = 0;
_gdk_win32_print_hpalette (HPALETTE hpal)
{
PALETTEENTRY *pe;
- gint n, npal;
+ int n, npal;
npal = palette_size (hpal);
pe = g_new (PALETTEENTRY, npal);
UINT32 dispconf_path_count;
fixedDISPLAYCONFIG_PATH_INFO *dispconf_paths;
DISPLAYCONFIG_MODE_INFO *dispconf_modes;
- gint path_index;
+ int path_index;
user32 = LoadLibraryA ("user32.dll");
for (path_index = 0; path_index < dispconf_path_count; path_index++)
{
fixedDISPLAYCONFIG_TARGET_DEVICE_NAME tdn;
- gint i;
+ int i;
GdkWin32Monitor *w32mon;
GdkMonitor *mon;
gchar *path, *path_lower;
static void
prune_monitors (EnumMonitorData *data)
{
- gint i;
+ int i;
for (i = 0; i < data->monitors->len; i++)
{
_gdk_win32_display_get_monitor_list (GdkWin32Display *win32_display)
{
EnumMonitorData data;
- gint i;
+ int i;
data.display = win32_display;
data.monitors = get_monitor_devices (win32_display);
void _gdk_surface_init_position (GdkSurface *window);
void _gdk_surface_move_resize_child (GdkSurface *window,
- gint x,
- gint y,
- gint width,
- gint height);
+ int x,
+ int y,
+ int width,
+ int height);
gboolean _gdk_win32_surface_enable_transparency (GdkSurface *window);
/* GdkSurfaceImpl methods */
void _gdk_win32_surface_scroll (GdkSurface *window,
- gint dx,
- gint dy);
+ int dx,
+ int dy);
void _gdk_win32_surface_move_region (GdkSurface *window,
const cairo_region_t *region,
- gint dx,
- gint dy);
+ int dx,
+ int dy);
void _gdk_win32_selection_init (void);
void gdk_win32_handle_table_remove (HANDLE handle);
HRGN _gdk_win32_cairo_region_to_hrgn (const cairo_region_t *region,
- gint x_origin,
- gint y_origin);
+ int x_origin,
+ int y_origin);
cairo_region_t *_gdk_win32_hrgn_to_region (HRGN hrgn,
guint scale);
* to the left and/or above the primary monitor) to get GDK
* coordinates, which should be non-negative on the whole screen.
*/
-extern gint _gdk_offset_x, _gdk_offset_y;
+extern int _gdk_offset_x, _gdk_offset_y;
extern HDC _gdk_display_hdc;
extern HINSTANCE _gdk_dll_hinstance;
extern HINSTANCE _gdk_app_hmodule;
-extern gint _gdk_input_ignore_core;
+extern int _gdk_input_ignore_core;
/* These are thread specific, but GDK/win32 works OK only when invoked
* from a single thread anyway.
/* Options */
extern gboolean _gdk_input_ignore_wintab;
-extern gint _gdk_max_colors;
+extern int _gdk_max_colors;
/* Convert a pixbuf to an HICON (or HCURSOR). Supports alpha under
* Windows XP, thresholds alpha otherwise.
*/
HICON _gdk_win32_texture_to_hicon (GdkTexture *texture);
HICON _gdk_win32_pixbuf_to_hcursor (GdkPixbuf *pixbuf,
- gint x_hotspot,
- gint y_hotspot);
+ int x_hotspot,
+ int y_hotspot);
void _gdk_win32_display_init_cursors (GdkWin32Display *display);
void _gdk_win32_display_finalize_cursors (GdkWin32Display *display);
struct _Win32Cursor {
GdkWin32CursorLoadType load_type;
gunichar2 *resource_name;
- gint width;
- gint height;
+ int width;
+ int height;
guint load_flags;
- gint xcursor_number;
+ int xcursor_number;
};
Win32CursorTheme *win32_cursor_theme_load (const gchar *name,
- gint size);
+ int size);
Win32Cursor * win32_cursor_theme_get_cursor (Win32CursorTheme *theme,
const gchar *name);
void win32_cursor_theme_destroy (Win32CursorTheme *theme);
void _gdk_win32_do_emit_configure_event (GdkSurface *window,
RECT rect);
void gdk_win32_surface_do_move_resize_drag (GdkSurface *window,
- gint x,
- gint y);
+ int x,
+ int y);
void gdk_win32_surface_end_move_resize_drag (GdkSurface *window);
gboolean _gdk_win32_surface_fill_min_max_info (GdkSurface *window,
MINMAXINFO *mmi);
PangoFontDescription *font_desc;
gchar *result, *font_desc_string;
int logpixelsy;
- gint font_size;
+ int font_size;
ncm.cbSize = sizeof(NONCLIENTMETRICSW);
if (!SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0))
*/
if (strcmp ("gtk-double-click-time", name) == 0)
{
- gint i = GetDoubleClickTime ();
+ int i = GetDoubleClickTime ();
GDK_NOTE(MISC, g_print("gdk_display_get_setting(\"%s\") : %d\n", name, i));
g_value_set_int (value, i);
return TRUE;
}
else if (strcmp ("gtk-double-click-distance", name) == 0)
{
- gint i = MAX(GetSystemMetrics (SM_CXDOUBLECLK), GetSystemMetrics (SM_CYDOUBLECLK));
+ int i = MAX(GetSystemMetrics (SM_CXDOUBLECLK), GetSystemMetrics (SM_CYDOUBLECLK));
GDK_NOTE(MISC, g_print("gdk_display_get_setting(\"%s\") : %d\n", name, i));
g_value_set_int (value, i);
return TRUE;
}
else if (strcmp ("gtk-dnd-drag-threshold", name) == 0)
{
- gint i = MAX(GetSystemMetrics (SM_CXDRAG), GetSystemMetrics (SM_CYDRAG));
+ int i = MAX(GetSystemMetrics (SM_CXDRAG), GetSystemMetrics (SM_CYDRAG));
GDK_NOTE(MISC, g_print("gdk_display_get_setting(\"%s\") : %d\n", name, i));
g_value_set_int (value, i);
return TRUE;
void
_gdk_win32_get_window_client_area_rect (GdkSurface *window,
- gint scale,
+ int scale,
RECT *rect)
{
- gint x, y, width, height;
+ int x, y, width, height;
x = y = 0;
width = gdk_surface_get_width (window);
GdkSurface *surface;
const gchar *title;
wchar_t *wtitle;
- gint window_width, window_height;
- gint window_x, window_y;
- gint offset_x = 0, offset_y = 0;
- gint real_x = 0, real_y = 0;
+ int window_width, window_height;
+ int window_x, window_y;
+ int offset_x = 0, offset_y = 0;
+ int real_x = 0, real_y = 0;
GdkFrameClock *frame_clock;
g_return_val_if_fail (display == _gdk_display, NULL);
static void
get_outer_rect (GdkSurface *window,
- gint width,
- gint height,
+ int width,
+ int height,
RECT *rect)
{
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
static void
adjust_for_gravity_hints (GdkSurface *window,
- RECT *outer_rect,
- gint *x,
- gint *y)
+ RECT *outer_rect,
+ int *x,
+ int *y)
{
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
if (impl->hint_flags & GDK_HINT_WIN_GRAVITY)
{
#ifdef G_ENABLE_DEBUG
- gint orig_x = *x, orig_y = *y;
+ int orig_x = *x, orig_y = *y;
#endif
switch (impl->hints.win_gravity)
static void
gdk_win32_surface_do_move (GdkSurface *window,
- gint x, gint y)
+ int x, int y)
{
RECT outer_rect;
GdkWin32Surface *impl;
void
gdk_win32_surface_resize (GdkSurface *window,
- gint width, gint height)
+ int width, int height)
{
RECT outer_rect;
static void
gdk_win32_surface_do_move_resize (GdkSurface *window,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
RECT outer_rect;
GdkWin32Surface *impl;
static void
gdk_win32_surface_move_resize_internal (GdkSurface *window,
gboolean with_move,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
GdkWin32Surface *surface = GDK_WIN32_SURFACE (window);
void
gdk_win32_surface_move_resize (GdkSurface *window,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
gdk_win32_surface_move_resize_internal (window, TRUE, x, y, width, height);
}
void
gdk_win32_surface_move (GdkSurface *surface,
- gint x,
- gint y)
+ int x,
+ int y)
{
gdk_win32_surface_move_resize_internal (surface, TRUE, x, y, -1, -1);
}
static void
gdk_win32_surface_get_geometry (GdkSurface *window,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+ int *x,
+ int *y,
+ int *width,
+ int *height)
{
if (!GDK_SURFACE_DESTROYED (window))
{
static void
gdk_win32_surface_get_root_coords (GdkSurface *window,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y)
+ int x,
+ int y,
+ int *root_x,
+ int *root_y)
{
- gint tx;
- gint ty;
+ int tx;
+ int ty;
POINT pt;
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
{
GdkDisplay *display;
GListModel *monitors;
- gint monitor_idx, other_monitor_idx;
+ int monitor_idx, other_monitor_idx;
GdkWin32Surface *impl = GDK_WIN32_SURFACE (context->window);
#if defined(MORE_AEROSNAP_DEBUGGING)
- gint i;
+ int i;
#endif
display = gdk_display_get_default ();
AeroSnapEdgeRegion snap_region;
gboolean move_edge[4] = { TRUE, FALSE, TRUE, TRUE };
gboolean resize_edge[2] = { TRUE, TRUE };
- gint diff;
- gint thickness, trigger_thickness;
+ int diff;
+ int thickness, trigger_thickness;
GdkMonitor *monitor;
monitor = g_list_model_get_item (monitors, monitor_idx);
stash_window (GdkSurface *window,
GdkWin32Surface *impl)
{
- gint x, y;
- gint width, wwidth;
- gint height, wheight;
+ int x, y;
+ int width, wwidth;
+ int height, wheight;
WINDOWPLACEMENT placement;
HMONITOR hmonitor;
MONITORINFO hmonitor_info;
snap_up (GdkSurface *window)
{
SHORT maxysize;
- gint x, y;
- gint width, height;
+ int x, y;
+ int width, height;
GdkWin32Surface *impl;
impl = GDK_WIN32_SURFACE (window);
GdkWin32Surface *impl;
GdkDisplay *display;
GListModel *monitors;
- gint n_monitors;
+ int n_monitors;
GdkSurfaceState surface_state = gdk_toplevel_get_state (GDK_TOPLEVEL (window));
gboolean minimized = surface_state & GDK_SURFACE_STATE_MINIMIZED;
gboolean maximized = surface_state & GDK_SURFACE_STATE_MAXIMIZED;
else if (impl->snap_state == GDK_WIN32_AEROSNAP_STATE_HALFRIGHT)
{
GdkMonitor *other;
- gint i;
+ int i;
unsnap (window, monitor);
for (i = 0; i < n_monitors; i++)
static gboolean
ensure_snap_indicator_surface (GdkW32DragMoveResizeContext *context,
- gint width,
- gint height,
+ int width,
+ int height,
guint scale)
{
if (context->indicator_surface != NULL &&
gboolean inward)
{
gdouble inverter;
- const gint gap = AEROSNAP_INDICATOR_EDGE_GAP;
+ const int gap = AEROSNAP_INDICATOR_EDGE_GAP;
#if defined(MORE_AEROSNAP_DEBUGGING)
GdkRectangle cache = *rect;
#endif
static void
rounded_rectangle (cairo_t *cr,
- gint x,
- gint y,
- gint width,
- gint height,
+ int x,
+ int y,
+ int width,
+ int height,
gdouble radius,
gdouble line_width,
GdkRGBA *fill,
static void
start_indicator (GdkSurface *window,
GdkW32DragMoveResizeContext *context,
- gint x,
- gint y,
+ int x,
+ int y,
GdkWin32AeroSnapState state)
{
GdkMonitor *monitor;
SWP_NOSIZE | SWP_NOREDRAW | SWP_HIDEWINDOW | SWP_NOACTIVATE));
}
-static gint
-point_in_aerosnap_region (gint x,
- gint y,
+static int
+point_in_aerosnap_region (int x,
+ int y,
AeroSnapEdgeRegion *region)
{
- gint edge, trigger;
+ int edge, trigger;
edge = (x >= region->edge.x &&
y >= region->edge.y &&
static void
handle_aerosnap_move_resize (GdkSurface *window,
GdkW32DragMoveResizeContext *context,
- gint x,
- gint y)
+ int x,
+ int y)
{
- gint i;
+ int i;
AeroSnapEdgeRegion *reg;
- gint maximize = 0;
- gint halfleft = 0;
- gint halfright = 0;
- gint fullup = 0;
+ int maximize = 0;
+ int halfleft = 0;
+ int halfright = 0;
+ int fullup = 0;
gboolean fullup_edge = FALSE;
if (context->op == GDK_WIN32_DRAGOP_RESIZE)
GdkW32WindowDragOp op,
GdkSurfaceEdge edge,
GdkDevice *device,
- gint button,
- gint x,
- gint y,
+ int button,
+ int x,
+ int y,
guint32 timestamp)
{
RECT rect;
GdkSurface *pointer_window;
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
gboolean maximized = gdk_toplevel_get_state (GDK_TOPLEVEL (window)) & GDK_SURFACE_STATE_MAXIMIZED;
- gint root_x, root_y;
+ int root_x, root_y;
gdk_win32_surface_get_root_coords (window, x, y, &root_x, &root_y);
impl->snap_state == GDK_WIN32_AEROSNAP_STATE_FULLUP))
{
GdkMonitor *monitor;
- gint wx, wy, wwidth, wheight;
- gint swx, swy, swwidth, swheight;
+ int wx, wy, wwidth, wheight;
+ int swx, swy, swwidth, swheight;
gboolean pointer_outside_of_window;
- gint offsetx, offsety;
+ int offsetx, offsety;
gboolean left_half;
GdkDisplay *display;
if (!pointer_outside_of_window && maximized)
{
WINDOWPLACEMENT placement;
- gint unmax_width, unmax_height;
- gint shadow_unmax_width, shadow_unmax_height;
+ int unmax_width, unmax_height;
+ int shadow_unmax_width, shadow_unmax_height;
placement.length = sizeof (placement);
API_CALL (GetWindowPlacement, (GDK_SURFACE_HWND (window), &placement));
void
gdk_win32_surface_do_move_resize_drag (GdkSurface *window,
- gint x,
- gint y)
+ int x,
+ int y)
{
RECT rect;
RECT new_rect;
- gint diffy, diffx;
+ int diffy, diffx;
MINMAXINFO mmi;
GdkWin32Surface *impl;
GdkW32DragMoveResizeContext *context;
- gint width;
- gint height;
+ int width;
+ int height;
impl = GDK_WIN32_SURFACE (window);
context = &impl->drag_move_resize_context;
static void
gdk_win32_surface_fullscreen (GdkSurface *window)
{
- gint x, y, width, height;
+ int x, y, width, height;
FullscreenInfo *fi;
HMONITOR monitor;
MONITORINFO mi;
GdkEvent *event)
{
double event_x, event_y;
- gint x, y;
+ int x, y;
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
switch ((int) event->event_type)
static void
gdk_win32_surface_set_shadow_width (GdkSurface *window,
- gint left,
- gint right,
- gint top,
- gint bottom)
+ int left,
+ int right,
+ int top,
+ int bottom)
{
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
}
-gint
+int
_gdk_win32_surface_get_scale_factor (GdkSurface *window)
{
GdkDisplay *display;
void
_gdk_win32_surface_get_unscaled_size (GdkSurface *window,
- gint *unscaled_width,
- gint *unscaled_height)
+ int *unscaled_width,
+ int *unscaled_height)
{
GdkWin32Surface *impl = GDK_WIN32_SURFACE (window);
* The op will be canceled only when *this* button
* is released.
*/
- gint button;
+ int button;
/* Initial cursor position when the operation began.
* Current cursor position is subtracted from it to find how far
* to move window border(s).
*/
- gint start_root_x;
- gint start_root_y;
+ int start_root_x;
+ int start_root_y;
/* Initial window rectangle (position and size).
* The window is resized/moved relative to this (see start_root_*).
/* Used to draw the indicator */
cairo_surface_t *indicator_surface;
- gint indicator_surface_width;
- gint indicator_surface_height;
+ int indicator_surface_width;
+ int indicator_surface_height;
/* Size/position of shape_indicator */
GdkRectangle indicator_window_rect;
wchar_t leading_surrogate_keyup;
/* Window size hints */
- gint hint_flags;
+ int hint_flags;
GdkGeometry hints;
/* Non-NULL for any window that is registered as a drop target.
GdkSurface *transient_owner;
GSList *transient_children;
- gint num_transients;
+ int num_transients;
gboolean changing_state;
- gint initial_x;
- gint initial_y;
+ int initial_x;
+ int initial_y;
/* left/right/top/bottom width of the shadow/resize-grip around the window */
RECT margins;
/* left+right and top+bottom from @margins */
- gint margins_x;
- gint margins_y;
+ int margins_x;
+ int margins_y;
/* Set to TRUE when GTK tells us that margins are 0 everywhere.
* We don't actually set margins to 0, we just set this bit.
* does not provide a way to query its size,
* so we have to remember it ourselves.
*/
- gint dib_width;
- gint dib_height;
+ int dib_width;
+ int dib_height;
/* If the client wants uniformly-transparent window,
* we remember the opacity value here and apply it
LONG_PTR temp_styles;
/* scale of window on HiDPI */
- gint surface_scale;
- gint unscaled_width;
- gint unscaled_height;
+ int surface_scale;
+ int unscaled_width;
+ int unscaled_height;
};
struct _GdkWin32SurfaceClass
void _gdk_win32_surface_update_style_bits (GdkSurface *window);
-gint _gdk_win32_surface_get_scale_factor (GdkSurface *window);
+int _gdk_win32_surface_get_scale_factor (GdkSurface *window);
void _gdk_win32_get_window_client_area_rect (GdkSurface *window,
- gint scale,
+ int scale,
RECT *rect);
void _gdk_win32_update_layered_window_from_cache (GdkSurface *window,
RECT *client_rect,
gboolean do_paint);
void gdk_win32_surface_move (GdkSurface *surface,
- gint x,
- gint y);
+ int x,
+ int y);
void gdk_win32_surface_move_resize (GdkSurface *window,
- gint x,
- gint y,
- gint width,
- gint height);
+ int x,
+ int y,
+ int width,
+ int height);
void
gdk_win32_surface_get_queued_window_rect (GdkSurface *surface,
- gint scale,
+ int scale,
RECT *return_window_rect);
void
GDK_AVAILABLE_IN_ALL
void gdk_win32_display_set_cursor_theme (GdkDisplay *display,
const gchar *name,
- gint size);
+ int size);
/**
* GdkWin32MessageFilterReturn:
*/
typedef GdkWin32MessageFilterReturn (*GdkWin32MessageFilterFunc) (GdkWin32Display *display,
MSG *message,
- gint *return_value,
+ int *return_value,
gpointer data);
GDK_AVAILABLE_IN_ALL
*/
struct _GdkWin32DragUtilityData
{
- gint last_x; /* Coordinates from last event, in GDK space */
- gint last_y;
+ int last_x; /* Coordinates from last event, in GDK space */
+ int last_y;
DWORD last_key_state; /* Key state from last event */
GdkWin32DndState state;
};
GdkWin32DragUtilityData util_data;
guint scale; /* Temporarily caches the HiDPI scale */
- gint hot_x; /* Hotspot offset from the top-left of the drag-window, scaled (can be added to GDK space coordinates) */
- gint hot_y;
- gint start_x; /* Coordinates of the drag start, in GDK space */
- gint start_y;
+ int hot_x; /* Hotspot offset from the top-left of the drag-window, scaled (can be added to GDK space coordinates) */
+ int hot_y;
+ int start_x; /* Coordinates of the drag start, in GDK space */
+ int start_y;
guint drag_status : 4; /* Current status of drag */
guint drop_failed : 1; /* Whether the drop was unsuccessful */
GdkDrop *_gdk_win32_get_drop_for_dest_surface (GdkSurface *dest);
gboolean _gdk_win32_local_drop_target_will_emit_motion (GdkDrop *drop,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
DWORD grfKeyState);
void _gdk_win32_local_drop_target_dragenter (GdkDrag *drag,
GdkSurface *dest_surface,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
DWORD grfKeyState,
guint32 time_,
GdkDragAction *actions);
void _gdk_win32_local_drop_target_dragover (GdkDrop *drop,
GdkDrag *drag,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
DWORD grfKeyState,
guint32 time_,
GdkDragAction *actions);
GDK_AVAILABLE_IN_ALL
gboolean gdk_win32_display_get_wgl_version (GdkDisplay *display,
- gint *major,
- gint *minor);
+ int *major,
+ int *minor);
G_END_DECLS
#endif
}
-static gint
+static int
gdk_handle_equal (HANDLE *a,
HANDLE *b)
{
{
ITfActiveLanguageProfileNotifySink itf_alpn_sink;
- gint ref_count;
+ int ref_count;
};
typedef struct _GdkWin32ALPNSink GdkWin32ALPNSink;
-static const struct { const gchar *name; const gchar *builtin; gint type; guchar width; guchar height; guchar hotx; guchar hoty; gchar *data; } cursors[] = {
+static const struct { const gchar *name; const gchar *builtin; int type; guchar width; guchar height; guchar hotx; guchar hoty; gchar *data; } cursors[] = {
{ "X_cursor", NULL, 0, 16, 16, 7, 7,
"\125\000\000\125\152\100\001\251\152\220\006\251\152\244\032\251"
"\032\251\152\244\006\252\252\220\001\252\252\100\000\152\251\000"
guint current_child;
guint n_children_found;
- gint current_request;
+ int current_request;
gboolean have_error;
gboolean child_has_error;
};
struct _GdkChildInfoX11
{
Window window;
- gint x;
- gint y;
- gint width;
- gint height;
+ int x;
+ int y;
+ int width;
+ int height;
guint is_mapped : 1;
guint has_wm_state : 1;
guint window_class : 2;
const char *mime_type;
GInputStream * (* convert) (GdkX11Clipboard *, GInputStream *, const char *, int);
const char *type;
- gint format;
+ int format;
} special_targets[] = {
{ "UTF8_STRING", "text/plain;charset=utf-8", no_convert, "UTF8_STRING", 8 },
{ "COMPOUND_TEXT", "text/plain;charset=utf-8", text_list_convert, "COMPOUND_TEXT", 8 },
static XcursorImage*
create_cursor_image (GdkTexture *texture,
- gint x,
- gint y,
- gint scale)
+ int x,
+ int y,
+ int scale)
{
XcursorImage *xcimage;
static const gchar *
name_fallback (const gchar *name)
{
- gint i;
+ int i;
for (i = 0; i < G_N_ELEMENTS (name_map); i++)
{
gdk_x11_cursor_create_for_name (GdkDisplay *display,
const gchar *name)
{
- gint i;
+ int i;
if (g_str_equal (name, "none"))
return get_blank_cursor (display);
void
gdk_x11_display_set_cursor_theme (GdkDisplay *display,
const gchar *theme,
- const gint size)
+ const int size)
{
#if defined(HAVE_XCURSOR) && defined(HAVE_XFIXES) && XFIXES_MAJOR >= 2
Display *xdisplay;
gchar *old_theme;
- gint old_size;
+ int old_size;
gpointer cursor, xcursor;
GHashTableIter iter;
{
GdkDevice parent_instance;
- gint device_id;
+ int device_id;
GArray *scroll_valuators;
gdouble *last_axes;
};
{
GdkDisplay *display;
XIDeviceInfo *info;
- gint i, j, ndevices;
+ int i, j, ndevices;
Screen *xscreen;
display = gdk_device_get_display (device);
case GDK_AXIS_Y:
case GDK_AXIS_IGNORE:
{
- gint root_x, root_y;
+ int root_x, root_y;
/* FIXME: Maybe root coords caching should happen here */
gdk_surface_get_origin (surface, &root_x, &root_y);
XIEventMask mask;
Window xwindow;
Cursor xcursor;
- gint status;
+ int status;
display = gdk_device_get_display (device);
device_manager_xi2 = GDK_X11_DEVICE_MANAGER_XI2 (GDK_X11_DISPLAY (display)->device_manager);
}
else
{
- gint width, height;
+ int width, height;
GList *toplevels, *list;
Window pointer_window;
guchar *
_gdk_x11_device_xi2_translate_event_mask (GdkX11DeviceManagerXI2 *device_manager_xi2,
GdkEventMask event_mask,
- gint *len)
+ int *len)
{
guchar *mask;
- gint minor;
+ int minor;
g_object_get (device_manager_xi2, "minor", &minor, NULL);
if (buttons_state)
{
- gint len, i;
+ int len, i;
/* We're only interested in the first 3 buttons */
len = MIN (3, buttons_state->mask_len * 8);
device->scroll_valuators->len);
}
-gint
+int
_gdk_x11_device_xi2_get_id (GdkX11DeviceXI2 *device)
{
g_return_val_if_fail (GDK_IS_X11_DEVICE_XI2 (device), 0);
gdouble
gdk_x11_device_xi2_get_last_axis_value (GdkX11DeviceXI2 *device,
- gint n_axis)
+ int n_axis)
{
if (n_axis >= gdk_device_get_n_axes (GDK_DEVICE (device)))
return 0;
void
gdk_x11_device_xi2_store_axes (GdkX11DeviceXI2 *device,
gdouble *axes,
- gint n_axes)
+ int n_axes)
{
g_free (device->last_axes);
**/
GdkDevice *
gdk_x11_device_manager_lookup (GdkX11DeviceManagerXI2 *device_manager,
- gint device_id)
+ int device_id)
{
g_return_val_if_fail (GDK_IS_X11_DEVICE_MANAGER_XI2 (device_manager), NULL);
*
* Returns: the XInput2 device ID.
**/
-gint
+int
gdk_x11_device_get_id (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
GList *devices;
- gint opcode;
- gint major;
- gint minor;
+ int opcode;
+ int major;
+ int minor;
};
struct _GdkX11DeviceManagerXI2Class
static gboolean initialized = FALSE;
static Atom label_atoms [GDK_AXIS_LAST] = { 0 };
GdkAxisUse use = GDK_AXIS_IGNORE;
- gint i;
+ int i;
if (!initialized)
{
XIAnyClassInfo **classes,
guint n_classes)
{
- gint i;
+ int i;
g_object_freeze_notify (G_OBJECT (device));
is_touch_device (XIAnyClassInfo **classes,
guint n_classes,
GdkInputSource *device_type,
- gint *num_touches)
+ int *num_touches)
{
#ifdef XINPUT_2_2
guint i;
GdkInputSource touch_source;
GdkDeviceType type;
GdkDevice *device;
- gint num_touches = 0;
+ int num_touches = 0;
gchar *vendor_id = NULL, *product_id = NULL;
if (dev->use == XIMasterKeyboard || dev->use == XISlaveKeyboard)
static void
remove_device (GdkX11DeviceManagerXI2 *device_manager,
- gint device_id)
+ int device_id)
{
GdkDevice *device;
Display *xdisplay;
XIDeviceInfo *info;
int ndevices;
- gint i;
+ int i;
display = device_manager->display;
xdisplay = GDK_DISPLAY_XDISPLAY (display);
}
static GdkCrossingMode
-translate_crossing_mode (gint mode)
+translate_crossing_mode (int mode)
{
switch (mode)
{
}
static GdkNotifyType
-translate_notify_type (gint detail)
+translate_notify_type (int detail)
{
switch (detail)
{
GdkDevice *
_gdk_x11_device_manager_xi2_lookup (GdkX11DeviceManagerXI2 *device_manager_xi2,
- gint device_id)
+ int device_id)
{
return g_hash_table_lookup (device_manager_xi2->id_table,
GINT_TO_POINTER (device_id));
static void gdk_internal_connection_watch (Display *display,
XPointer arg,
- gint fd,
+ int fd,
gboolean opening,
XPointer *watch_data);
struct _GdkEventTypeX11
{
- gint base;
- gint n_events;
+ int base;
+ int n_events;
};
/* Note that we never *directly* use WM_LOCALE_NAME, WM_PROTOCOLS,
GdkDisplay *display = GDK_SURFACE_DISPLAY (surface);
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
guchar *data;
GdkX11Screen *screen = GDK_SURFACE_SCREEN (surface);
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
guchar *data;
GdkDisplay *display = GDK_SURFACE_DISPLAY (surface);
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
guchar *data;
!xevent->xconfigure.override_redirect &&
!GDK_SURFACE_DESTROYED (surface))
{
- gint tx = 0;
- gint ty = 0;
+ int tx = 0;
+ int ty = 0;
Window child_window = 0;
x = y = 0;
void
gdk_display_setup_window_visual (GdkDisplay *display,
- gint depth,
+ int depth,
Visual *visual,
Colormap colormap,
gboolean rgba)
Display *xdisplay;
GdkDisplay *display;
GdkX11Display *display_x11;
- gint argc;
+ int argc;
gchar *argv[1];
XClassHint *class_hint;
- gint ignore;
- gint maj, min;
+ int ignore;
+ int maj, min;
char *cm_name;
XInitThreads ();
#ifdef HAVE_XKB
{
- gint xkb_major = XkbMajorVersion;
- gint xkb_minor = XkbMinorVersion;
+ int xkb_major = XkbMajorVersion;
+ int xkb_minor = XkbMinorVersion;
if (XkbLibraryVersion (&xkb_major, &xkb_minor))
{
xkb_major = XkbMajorVersion;
struct _GdkInternalConnection
{
- gint fd;
+ int fd;
GSource *source;
Display *display;
};
static void
gdk_internal_connection_watch (Display *display,
XPointer arg,
- gint fd,
+ int fd,
gboolean opening,
XPointer *watch_data)
{
void
_gdk_x11_display_update_grab_info (GdkDisplay *display,
GdkDevice *device,
- gint status)
+ int status)
{
if (status == GrabSuccess)
_gdk_x11_roundtrip_async (display, device_grab_update_callback, device);
g_slist_prepend (display_x11->error_traps, trap);
}
-static gint
+static int
gdk_x11_display_error_trap_pop_internal (GdkDisplay *display,
gboolean need_code)
{
*/
void
gdk_x11_display_set_surface_scale (GdkDisplay *display,
- gint scale)
+ int scale)
{
GdkX11Screen *x11_screen;
gboolean need_reread_settings = FALSE;
*
* Returns: X error code or 0 on success
*/
-gint
+int
gdk_x11_display_error_trap_pop (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_X11_DISPLAY (display), Success);
GSource *event_source;
- gint grab_count;
+ int grab_count;
/* Visual infos for creating Windows */
int window_depth;
Colormap window_colormap;
/* Keyboard related information */
- gint xkb_event_type;
+ int xkb_event_type;
gboolean use_xkb;
/* Whether we were able to turn on detectable-autorepeat using
guint keymap_serial;
gboolean have_xfixes;
- gint xfixes_event_base;
+ int xfixes_event_base;
gboolean have_xcomposite;
gboolean have_randr12;
gboolean have_randr13;
gboolean have_randr15;
- gint xrandr_event_base;
+ int xrandr_event_base;
/* If the SECURITY extension is in place, whether this client holds
* a trusted authorization and so is allowed to make various requests
guint have_shapes : 1;
guint have_input_shapes : 1;
- gint shape_event_base;
+ int shape_event_base;
GSList *error_traps;
- gint wm_moveresize_button;
+ int wm_moveresize_button;
/* GLX information */
- gint glx_version;
- gint glx_error_base;
- gint glx_event_base;
+ int glx_version;
+ int glx_error_base;
+ int glx_event_base;
/* Translation between X server time and system-local monotonic time */
gint64 server_time_query_time;
guint has_async_glx_swap_buffers : 1;
#ifdef HAVE_XDAMAGE
- gint damage_event_base;
- gint damage_error_base;
+ int damage_event_base;
+ int damage_error_base;
guint have_damage;
#endif
};
typedef struct {
guint32 xid;
- gint x, y, width, height;
+ int x, y, width, height;
gboolean mapped;
gboolean shape_selected;
gboolean shape_valid;
GHashTable *child_hash;
guint old_event_mask;
GdkDisplay *display;
- gint ref_count;
+ int ref_count;
};
GdkDragProtocol protocol;
- gint start_x; /* Where the drag started */
- gint start_y;
+ int start_x; /* Where the drag started */
+ int start_y;
guint16 last_x; /* Coordinates from last event */
guint16 last_y;
gulong timestamp; /* Timestamp we claimed the DND selection with */
GdkDragAction actions;
GdkDragAction current_action;
- gint hot_x;
- gint hot_y;
+ int hot_x;
+ int hot_y;
Window dest_xid; /* The last window we looked up */
Window proxy_xid; /* The proxy window for dest_xid (or dest_xid if no proxying happens) */
};
typedef struct {
- gint keysym;
- gint modifiers;
+ int keysym;
+ int modifiers;
} GrabKey;
static GrabKey grab_keys[] = {
static void gdk_x11_drag_finalize (GObject *object);
static Window gdk_x11_drag_find_surface (GdkDrag *drag,
GdkSurface *drag_surface,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
GdkDragProtocol *protocol);
static gboolean gdk_x11_drag_drag_motion (GdkDrag *drag,
Window proxy_xid,
GdkDragProtocol protocol,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
GdkDragAction suggested_action,
GdkDragAction possible_actions,
guint32 time);
guint32 time_);
static GdkSurface * gdk_x11_drag_get_drag_surface (GdkDrag *drag);
static void gdk_x11_drag_set_hotspot (GdkDrag *drag,
- gint hot_x,
- gint hot_y);
+ int hot_x,
+ int hot_y);
static void gdk_x11_drag_drop_done (GdkDrag *drag,
gboolean success);
static void gdk_x11_drag_set_cursor (GdkDrag *drag,
static void
gdk_surface_cache_add (GdkSurfaceCache *cache,
guint32 xid,
- gint x,
- gint y,
- gint width,
- gint height,
+ int x,
+ int y,
+ int width,
+ int height,
gboolean mapped)
{
GdkCacheChild *child = g_new (GdkCacheChild, 1);
GList *toplevel_windows, *list;
GdkSurface *surface;
GdkX11Surface *impl;
- gint x, y, width, height;
+ int x, y, width, height;
toplevel_windows = gdk_x11_display_get_toplevel_windows (display);
for (list = toplevel_windows; list; list = list->next)
static gboolean
is_pointer_within_shape (GdkDisplay *display,
GdkCacheChild *child,
- gint x_pos,
- gint y_pos)
+ int x_pos,
+ int y_pos)
{
if (!child->shape_selected)
{
get_client_window_at_coords_recurse (GdkDisplay *display,
Window win,
gboolean is_toplevel,
- gint x,
- gint y)
+ int x,
+ int y)
{
GdkChildInfoX11 *children;
unsigned int nchildren;
static Window
get_client_window_at_coords (GdkSurfaceCache *cache,
Window ignore,
- gint x_root,
- gint y_root)
+ int x_root,
+ int y_root)
{
GList *tmp_list;
Window retval = None;
{ "XdndActionPrivate", GDK_ACTION_COPY },
};
-static const gint xdnd_n_actions = G_N_ELEMENTS (xdnd_actions_table);
+static const int xdnd_n_actions = G_N_ELEMENTS (xdnd_actions_table);
static GdkDragAction
xdnd_action_from_atom (GdkDisplay *display,
Atom xatom)
{
const char *name;
- gint i;
+ int i;
if (xatom == None)
return 0;
xdnd_action_to_atom (GdkDisplay *display,
GdkDragAction action)
{
- gint i;
+ int i;
for (i = 0; i < xdnd_n_actions; i++)
if (action == xdnd_actions_table[i].action)
{
GdkDrag *drag = GDK_DRAG (drag_x11);
Atom *atomlist;
- gint i;
- gint n_atoms;
+ int i;
+ int n_atoms;
guint actions;
GdkDisplay *display = gdk_drag_get_display (drag);
static void
xdnd_send_motion (GdkX11Drag *drag_x11,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
GdkDragAction action,
guint32 time)
{
static Window
gdk_x11_drag_find_surface (GdkDrag *drag,
GdkSurface *drag_surface,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
GdkDragProtocol *protocol)
{
GdkX11Screen *screen_x11;
gdk_x11_drag_drag_motion (GdkDrag *drag,
Window proxy_xid,
GdkDragProtocol protocol,
- gint x_root,
- gint y_root,
+ int x_root,
+ int y_root,
GdkDragAction suggested_action,
GdkDragAction possible_actions,
guint32 time)
static void
gdk_x11_drag_set_hotspot (GdkDrag *drag,
- gint hot_x,
- gint hot_y)
+ int hot_x,
+ int hot_y)
{
GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkDisplay *display;
Window root;
GdkSeat *seat;
- gint keycode, i;
+ int keycode, i;
GdkCursor *cursor;
if (!x11_drag->ipc_surface)
for (i = 0; i < G_N_ELEMENTS (grab_keys); ++i)
{
- gint deviceid = gdk_x11_device_get_id (gdk_seat_get_keyboard (seat));
+ int deviceid = gdk_x11_device_get_id (gdk_seat_get_keyboard (seat));
unsigned char mask[XIMaskLen(XI_LASTEVENT)];
XIGrabModifiers mods;
XIEventMask evmask;
- gint num_mods;
+ int num_mods;
keycode = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display),
grab_keys[i].keysym);
GdkDisplay *display;
GdkDevice *keyboard;
Window root;
- gint keycode, i;
+ int keycode, i;
if (!x11_drag->grab_seat)
return;
for (i = 0; i < G_N_ELEMENTS (grab_keys); ++i)
{
XIGrabModifiers mods;
- gint num_mods;
+ int num_mods;
keycode = XKeysymToKeycode (GDK_DISPLAY_XDISPLAY (display),
grab_keys[i].keysym);
static void
gdk_drag_get_current_actions (GdkModifierType state,
- gint button,
+ int button,
GdkDragAction actions,
GdkDragAction *suggested_action,
GdkDragAction *possible_actions)
GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkModifierType state;
GdkDevice *pointer;
- gint dx, dy;
+ int dx, dy;
dx = dy = 0;
state = gdk_event_get_modifier_state (event);
{ "XdndActionPrivate", GDK_ACTION_COPY },
};
-static const gint xdnd_n_actions = G_N_ELEMENTS (xdnd_actions_table);
+static const int xdnd_n_actions = G_N_ELEMENTS (xdnd_actions_table);
static GdkDragAction
xdnd_action_from_atom (GdkDisplay *display,
Atom xatom)
{
const char *name;
- gint i;
+ int i;
if (xatom == None)
return 0;
xdnd_action_to_atom (GdkDisplay *display,
GdkDragAction action)
{
- gint i;
+ int i;
for (i = 0; i < xdnd_n_actions; i++)
if (action == xdnd_actions_table[i].action)
gulong nitems, after;
guchar *data;
Atom *atoms;
- gint i;
+ int i;
drag = gdk_drop_get_drag (drop);
GdkX11Drop *drop_x11;
GdkDrag *drag;
GdkSeat *seat;
- gint i;
+ int i;
Atom type;
int format;
gulong nitems, after;
GPtrArray *formats;
Window source_window;
gboolean get_types;
- gint version;
+ int version;
source_window = xevent->xclient.data.l[0];
get_types = ((xevent->xclient.data.l[1] & 1) != 0);
static gboolean gdk_event_source_prepare (GSource *source,
- gint *timeout);
+ int *timeout);
static gboolean gdk_event_source_check (GSource *source);
static gboolean gdk_event_source_dispatch (GSource *source,
GSourceFunc callback,
static gboolean
gdk_event_source_prepare (GSource *source,
- gint *timeout)
+ int *timeout)
{
GdkDisplay *display = ((GdkEventSource*) source)->display;
gboolean retval;
{
unsigned int xmask = extra_x_mask;
GList *list;
- gint i;
+ int i;
list = source->translators;
{
gboolean found;
Atom type_return;
- gint format_return;
+ int format_return;
gulong nitems_return;
gulong bytes_after_return;
guchar *data = NULL;
*/
gboolean
gdk_x11_display_get_glx_version (GdkDisplay *display,
- gint *major,
- gint *minor)
+ int *major,
+ int *minor)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
{
GdkKeymap parent_instance;
- gint min_keycode;
- gint max_keycode;
+ int min_keycode;
+ int max_keycode;
KeySym* keymap;
- gint keysyms_per_keycode;
+ int keysyms_per_keycode;
XModifierKeymap* mod_keymap;
guint lock_keysym;
GdkModifierType group_switch_mask;
{ NULL, 0, 0 }
};
- gint i, j, k;
+ int i, j, k;
if (!vmods[0].atom)
for (i = 0; vmods[i].name; i++)
* otherwise we lose a whole group of keys
*/
#define KEYSYM_INDEX(keymap_impl, group, level) \
- (2 * ((group) % (gint)((keymap_impl->keysyms_per_keycode + 1) / 2)) + (level))
+ (2 * ((group) % (int)((keymap_impl->keysyms_per_keycode + 1) / 2)) + (level))
#define KEYSYM_IS_KEYPAD(s) (((s) >= 0xff80 && (s) <= 0xffbd) || \
((s) >= 0x11000000 && (s) <= 0x1100ffff))
-static gint
+static int
get_symbol (const KeySym *syms,
GdkX11Keymap *keymap_x11,
- gint group,
- gint level)
+ int group,
+ int level)
{
- gint index;
+ int index;
index = KEYSYM_INDEX(keymap_x11, group, level);
if (index >= keymap_x11->keysyms_per_keycode)
static void
set_symbol (KeySym *syms,
GdkX11Keymap *keymap_x11,
- gint group,
- gint level,
+ int group,
+ int level,
KeySym sym)
{
- gint index;
+ int index;
index = KEYSYM_INDEX(keymap_x11, group, level);
if (index >= keymap_x11->keysyms_per_keycode)
if (keymap_x11->keymap == NULL ||
keymap_x11->current_serial != display_x11->keymap_serial)
{
- gint i;
- gint map_size;
- gint keycode;
+ int i;
+ int map_size;
+ int keycode;
keymap_x11->current_serial = display_x11->keymap_serial;
for (i = 0; i < map_size; i++)
{
/* Get the key code at this point in the map. */
- gint code = keymap_x11->mod_keymap->modifiermap[i];
- gint j;
+ int code = keymap_x11->mod_keymap->modifiermap[i];
+ int j;
KeySym *syms;
guint mask;
#ifdef HAVE_XKB
static PangoDirection
get_direction (XkbDescRec *xkb,
- gint group)
+ int group)
{
- gint code;
+ int code;
- gint rtl_minus_ltr = 0; /* total number of RTL keysyms minus LTR ones */
+ int rtl_minus_ltr = 0; /* total number of RTL keysyms minus LTR ones */
for (code = xkb->min_key_code; code <= xkb->max_key_code; code++)
{
- gint level = 0;
+ int level = 0;
KeySym sym = XkbKeySymEntry (xkb, code, level, group);
PangoDirection dir = gdk_unichar_direction (gdk_keyval_to_unicode (sym));
static PangoDirection
get_direction_from_cache (GdkX11Keymap *keymap_x11,
XkbDescPtr xkb,
- gint group)
+ int group)
{
Atom group_atom = xkb->names->groups[group];
DirectionCacheEntry *cache = keymap_x11->group_direction_cache;
PangoDirection direction = PANGO_DIRECTION_NEUTRAL;
- gint i;
+ int i;
if (keymap_x11->have_direction)
{
/* insert in cache */
if (!cache_hit)
{
- gint oldest = 0;
+ int oldest = 0;
direction = get_direction (xkb, group);
static gboolean
update_direction (GdkX11Keymap *keymap_x11,
GdkDevice *keyboard,
- gint group)
+ int group)
{
XkbDescPtr xkb = get_xkb (keymap_x11);
Atom group_atom;
static gboolean
update_lock_state (GdkX11Keymap *keymap_x11,
GdkDevice *keyboard,
- gint locked_mods,
- gint effective_mods)
+ int locked_mods,
+ int effective_mods)
{
XkbDescPtr xkb G_GNUC_UNUSED;
gboolean have_lock_state;
/* See sec 15.3.4 in XKB docs */
XkbDescRec *xkb = get_xkb (keymap_x11);
- gint keycode;
+ int keycode;
keycode = keymap_x11->min_keycode;
while (keycode <= keymap_x11->max_keycode)
{
- gint max_shift_levels = XkbKeyGroupsWidth (xkb, keycode); /* "key width" */
- gint group = 0;
- gint level = 0;
- gint total_syms = XkbKeyNumSyms (xkb, keycode);
- gint i = 0;
+ int max_shift_levels = XkbKeyGroupsWidth (xkb, keycode); /* "key width" */
+ int group = 0;
+ int level = 0;
+ int total_syms = XkbKeyNumSyms (xkb, keycode);
+ int i = 0;
KeySym *entry;
/* entry is an array with all syms for group 0, all
#endif
{
const KeySym *map = get_keymap (keymap_x11);
- gint keycode;
+ int keycode;
keycode = keymap_x11->min_keycode;
while (keycode <= keymap_x11->max_keycode)
{
const KeySym *syms = map + (keycode - keymap_x11->min_keycode) * keymap_x11->keysyms_per_keycode;
- gint i = 0;
+ int i = 0;
while (i < keymap_x11->keysyms_per_keycode)
{
guint hardware_keycode,
GdkKeymapKey **keys,
guint **keyvals,
- gint *n_entries)
+ int *n_entries)
{
GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
GArray *key_array;
/* See sec 15.3.4 in XKB docs */
XkbDescRec *xkb = get_xkb (keymap_x11);
- gint max_shift_levels;
- gint group = 0;
- gint level = 0;
- gint total_syms;
- gint i = 0;
+ int max_shift_levels;
+ int group = 0;
+ int level = 0;
+ int total_syms;
+ int i = 0;
KeySym *entry;
max_shift_levels = XkbKeyGroupsWidth (xkb, hardware_keycode); /* "key width" */
{
const KeySym *map = get_keymap (keymap_x11);
const KeySym *syms;
- gint i = 0;
+ int i = 0;
syms = map + (hardware_keycode - keymap_x11->min_keycode) * keymap_x11->keysyms_per_keycode;
static guint
translate_keysym (GdkX11Keymap *keymap_x11,
guint hardware_keycode,
- gint group,
+ int group,
GdkModifierType state,
- gint *effective_group,
- gint *effective_level)
+ int *effective_group,
+ int *effective_level)
{
const KeySym *map = get_keymap (keymap_x11);
const KeySym *syms = map + (hardware_keycode - keymap_x11->min_keycode) * keymap_x11->keysyms_per_keycode;
#define SYM(k,g,l) get_symbol (syms, k,g,l)
GdkModifierType shift_modifiers;
- gint shift_level;
+ int shift_level;
guint tmp_keyval;
shift_modifiers = GDK_SHIFT_MASK;
gdk_x11_keymap_translate_keyboard_state (GdkKeymap *keymap,
guint hardware_keycode,
GdkModifierType state,
- gint group,
+ int group,
guint *keyval,
- gint *effective_group,
- gint *level,
+ int *effective_group,
+ int *level,
GdkModifierType *consumed_modifiers)
{
GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
*
* Returns: the index of the active keyboard group for the event
*/
-gint
+int
gdk_x11_keymap_get_group_for_state (GdkKeymap *keymap,
guint state)
{
guint keycode)
{
GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
- gint i;
+ int i;
g_return_val_if_fail (GDK_IS_X11_KEYMAP (keymap), FALSE);
GType gdk_x11_keymap_get_type (void);
-gint gdk_x11_keymap_get_group_for_state (GdkKeymap *keymap,
+int gdk_x11_keymap_get_group_for_state (GdkKeymap *keymap,
guint state);
gboolean gdk_x11_keymap_key_is_modifier (GdkKeymap *keymap,
}
GdkGrabStatus
-_gdk_x11_convert_grab_status (gint status)
+_gdk_x11_convert_grab_status (int status)
{
switch (status)
{
}
}
-gint
+int
_gdk_x11_display_send_xevent (GdkDisplay *display,
Window window,
gboolean propagate,
void
_gdk_x11_region_get_xrectangles (const cairo_region_t *region,
- gint x_offset,
- gint y_offset,
- gint scale,
+ int x_offset,
+ int y_offset,
+ int scale,
XRectangle **rects,
- gint *n_rects)
+ int *n_rects)
{
XRectangle *rectangles;
cairo_rectangle_int_t box;
- gint i, n;
+ int i, n;
n = cairo_region_num_rectangles (region);
rectangles = g_new (XRectangle, n);
void _gdk_x11_error_handler_pop (void);
void gdk_display_setup_window_visual (GdkDisplay *display,
- gint depth,
+ int depth,
Visual *visual,
Colormap colormap,
gboolean rgba);
void _gdk_x11_display_remove_window (GdkDisplay *display,
XID xid);
-gint _gdk_x11_display_send_xevent (GdkDisplay *display,
- Window window,
- gboolean propagate,
- glong event_mask,
- XEvent *event_send);
+int _gdk_x11_display_send_xevent (GdkDisplay *display,
+ Window window,
+ gboolean propagate,
+ glong event_mask,
+ XEvent *event_send);
cairo_region_t* _gdk_x11_xwindow_get_shape (Display *xdisplay,
Window window,
- gint scale,
- gint shape_type);
+ int scale,
+ int shape_type);
void _gdk_x11_region_get_xrectangles (const cairo_region_t *region,
- gint x_offset,
- gint y_offset,
- gint scale,
+ int x_offset,
+ int y_offset,
+ int scale,
XRectangle **rects,
- gint *n_rects);
+ int *n_rects);
gboolean _gdk_x11_moveresize_handle_event (const XEvent *event);
gboolean _gdk_x11_moveresize_configure_done (GdkDisplay *display,
void _gdk_x11_display_update_grab_info (GdkDisplay *display,
GdkDevice *device,
- gint status);
+ int status);
void _gdk_x11_display_update_grab_info_ungrab (GdkDisplay *display,
GdkDevice *device,
guint32 time,
GdkAppLaunchContext *_gdk_x11_display_get_app_launch_context (GdkDisplay *display);
-gint _gdk_x11_display_text_property_to_utf8_list (GdkDisplay *display,
+int _gdk_x11_display_text_property_to_utf8_list (GdkDisplay *display,
const char *encoding,
- gint format,
+ int format,
const guchar *text,
- gint length,
+ int length,
gchar ***list);
char * gdk_x11_utf8_to_string_target (const char *utf8_str,
gboolean return_latin1);
guchar * _gdk_x11_device_xi2_translate_event_mask (GdkX11DeviceManagerXI2 *device_manager_xi2,
GdkEventMask event_mask,
- gint *len);
+ int *len);
guint _gdk_x11_device_xi2_translate_state (XIModifierState *mods_state,
XIButtonState *buttons_state,
XIGroupState *group_state);
-gint _gdk_x11_device_xi2_get_id (GdkX11DeviceXI2 *device);
+int _gdk_x11_device_xi2_get_id (GdkX11DeviceXI2 *device);
void _gdk_device_xi2_unset_scroll_valuators (GdkX11DeviceXI2 *device);
GdkDevice * _gdk_x11_device_manager_xi2_lookup (GdkX11DeviceManagerXI2 *device_manager_xi2,
- gint device_id);
+ int device_id);
void _gdk_x11_device_xi2_add_scroll_valuator (GdkX11DeviceXI2 *device,
guint n_valuator,
GdkScrollDirection direction,
void _gdk_device_xi2_reset_scroll_valuators (GdkX11DeviceXI2 *device);
gdouble gdk_x11_device_xi2_get_last_axis_value (GdkX11DeviceXI2 *device,
- gint n_axis);
+ int n_axis);
void gdk_x11_device_xi2_store_axes (GdkX11DeviceXI2 *device,
gdouble *axes,
- gint n_axes);
+ int n_axes);
gboolean _gdk_x11_display_supports_cursor_alpha (GdkDisplay *display);
gboolean _gdk_x11_display_supports_cursor_color (GdkDisplay *display);
void _gdk_x11_precache_atoms (GdkDisplay *display,
const gchar * const *atom_names,
- gint n_atoms);
+ int n_atoms);
Atom _gdk_x11_get_xatom_for_display_printf (GdkDisplay *display,
const gchar *format,
double dy);
void gdk_x11_surface_get_root_coords (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y);
+ int x,
+ int y,
+ int *root_x,
+ int *root_y);
void gdk_x11_surface_show (GdkSurface *surface,
gboolean already_mapped);
double opacity);
gboolean gdk_x11_surface_supports_edge_constraints (GdkSurface *surface);
-GdkGrabStatus _gdk_x11_convert_grab_status (gint status);
+GdkGrabStatus _gdk_x11_convert_grab_status (int status);
cairo_surface_t * _gdk_x11_display_create_bitmap_surface (GdkDisplay *display,
int width,
int height);
-extern const gint _gdk_x11_event_mask_table[];
-extern const gint _gdk_x11_event_mask_table_size;
+extern const int _gdk_x11_event_mask_table[];
+extern const int _gdk_x11_event_mask_table_size;
#define GDK_SCREEN_DISPLAY(screen) (GDK_X11_SCREEN (screen)->display)
#define GDK_SCREEN_XROOTWIN(screen) (GDK_X11_SCREEN (screen)->xroot_window)
void
_gdk_x11_precache_atoms (GdkDisplay *display,
const gchar * const *atom_names,
- gint n_atoms)
+ int n_atoms)
{
Atom *xatoms;
const char **xatom_names;
- gint n_xatoms;
- gint i;
+ int n_xatoms;
+ int i;
xatoms = g_new (Atom, n_atoms);
xatom_names = g_new (const char *, n_atoms);
gdk_x11_screen_finalize (GObject *object)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
- gint i;
+ int i;
/* Visual Part */
for (i = 0; i < x11_screen->nvisuals; i++)
*/
XID
gdk_x11_screen_get_monitor_output (GdkX11Screen *x11_screen,
- gint monitor_num)
+ int monitor_num)
{
GdkX11Display *x11_display = GDK_X11_DISPLAY (x11_screen->display);
GdkX11Monitor *monitor;
GdkX11Screen *
_gdk_x11_screen_new (GdkDisplay *display,
- gint screen_number,
+ int screen_number,
gboolean setup_display)
{
GdkX11Screen *x11_screen;
void
_gdk_x11_screen_set_surface_scale (GdkX11Screen *x11_screen,
- gint scale)
+ int scale)
{
GdkX11Display *x11_display = GDK_X11_DISPLAY (x11_screen->display);
GList *toplevels, *l;
void
_gdk_x11_screen_get_edge_monitors (GdkX11Screen *x11_screen,
- gint *top,
- gint *bottom,
- gint *left,
- gint *right)
+ int *top,
+ int *bottom,
+ int *left,
+ int *right)
{
#ifdef HAVE_XFREE_XINERAMA
- gint top_most_pos = HeightOfScreen (x11_screen->xscreen);
- gint left_most_pos = WidthOfScreen (x11_screen->xscreen);
- gint bottom_most_pos = 0;
- gint right_most_pos = 0;
- gint i;
+ int top_most_pos = HeightOfScreen (x11_screen->xscreen);
+ int left_most_pos = WidthOfScreen (x11_screen->xscreen);
+ int bottom_most_pos = 0;
+ int right_most_pos = 0;
+ int i;
XineramaScreenInfo *x_monitors;
int x_n_monitors;
#endif
{
GdkDisplay *display;
Atom type;
- gint format;
+ int format;
gulong n_items;
gulong bytes_after;
guchar *data;
GdkDisplay *display;
Window window;
GTimeVal tv;
- gint error;
+ int error;
display = x11_screen->display;
* refetch it.
*/
Atom type;
- gint format;
+ int format;
gulong bytes_after;
x11_screen->need_refetch_net_supported = FALSE;
if (x11_screen->wmspec_check_window != None)
{
Atom type;
- gint format;
+ int format;
gulong n_items;
gulong bytes_after;
gchar *name;
{
guint32 prop = 0;
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
guchar *data;
Display *xdisplay;
Screen *xscreen;
Window xroot_window;
- gint screen_num;
+ int screen_num;
- gint surface_scale;
+ int surface_scale;
gboolean fixed_surface_scale;
/* Xft resources for the display, used for default values for
* the Xft/ XSETTINGS
*/
- gint xft_hintstyle;
- gint xft_rgba;
- gint xft_dpi;
+ int xft_hintstyle;
+ int xft_rgba;
+ int xft_dpi;
/* Window manager */
long last_wmspec_check_time;
guint xft_hinting : 1;
/* Visual Part */
- gint nvisuals;
+ int nvisuals;
GdkX11Visual **visuals;
GdkX11Visual *system_visual;
- gint available_depths[7];
+ int available_depths[7];
GdkVisualType available_types[6];
gint16 navailable_depths;
gint16 navailable_types;
GType _gdk_x11_screen_get_type (void);
GdkX11Screen *_gdk_x11_screen_new (GdkDisplay *display,
- gint screen_number,
+ int screen_number,
gboolean setup_display);
void _gdk_x11_screen_update_visuals_for_gl (GdkX11Screen *screen);
void _gdk_x11_screen_size_changed (GdkX11Screen *screen,
const XEvent *event);
void _gdk_x11_screen_get_edge_monitors (GdkX11Screen *screen,
- gint *top,
- gint *bottom,
- gint *left,
- gint *right);
+ int *top,
+ int *bottom,
+ int *left,
+ int *right);
void _gdk_x11_screen_set_surface_scale (GdkX11Screen *x11_screen,
int scale);
gboolean _gdk_x11_screen_get_monitor_work_area (GdkX11Screen *screen,
* Returns: the number of strings stored in list, or 0,
* if the conversion failed
*/
-gint
+int
gdk_x11_display_text_property_to_text_list (GdkDisplay *display,
const char *encoding,
- gint format,
+ int format,
const guchar *text,
- gint length,
+ int length,
gchar ***list)
{
XTextProperty property;
- gint count = 0;
- gint res;
+ int count = 0;
+ int res;
gchar **local_list;
g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
XFreeStringList (list);
}
-static gint
+static int
make_list (const gchar *text,
- gint length,
+ int length,
gboolean latin1,
gchar ***list)
{
GSList *strings = NULL;
- gint n_strings = 0;
- gint i;
+ int n_strings = 0;
+ int i;
const gchar *p = text;
const gchar *q;
GSList *tmp_list;
return n_strings;
}
-gint
+int
_gdk_x11_display_text_property_to_utf8_list (GdkDisplay *display,
const char *encoding,
- gint format,
+ int format,
const guchar *text,
- gint length,
+ int length,
gchar ***list)
{
if (g_str_equal (encoding, "STRING"))
else
{
gchar **local_list;
- gint local_count;
- gint i;
+ int local_count;
+ int i;
const gchar *charset = NULL;
gboolean need_conversion = !g_get_charset (&charset);
- gint count = 0;
+ int count = 0;
GError *error = NULL;
/* Probably COMPOUND text, we fall back to Xlib routines
*
* Returns: 0 upon success, non-zero upon failure
*/
-gint
+int
gdk_x11_display_string_to_compound_text (GdkDisplay *display,
const char *str,
const char **encoding,
- gint *format,
+ int *format,
guchar **ctext,
- gint *length)
+ int *length)
{
- gint res;
+ int res;
XTextProperty property;
g_return_val_if_fail (GDK_IS_DISPLAY (display), 0);
gdk_x11_display_utf8_to_compound_text (GdkDisplay *display,
const char *str,
const char **encoding,
- gint *format,
+ int *format,
guchar **ctext,
- gint *length)
+ int *length)
{
gboolean need_conversion;
const gchar *charset;
Window owner,
Atom property,
Atom *ret_type,
- gint *ret_format)
+ int *ret_format)
{
gulong nitems;
gulong nbytes;
Atom prop_type;
- gint prop_format;
+ int prop_format;
guchar *data = NULL;
if (XGetWindowProperty (display, owner, property,
Window xwindow;
GBytes *bytes;
Atom type;
- gint format;
+ int format;
xdisplay = gdk_x11_display_get_xdisplay (priv->display);
xwindow = GDK_X11_DISPLAY (priv->display)->leader_window;
const char *x_target;
const char *mime_type;
const char *type;
- gint format;
+ int format;
MimeTypeHandleFunc handler;
} special_targets[] = {
{ "UTF8_STRING", "text/plain;charset=utf-8", "UTF8_STRING", 8, handle_utf8 },
gulong n_atoms;
gulong nbytes;
Atom prop_type;
- gint prop_format;
+ int prop_format;
Atom *atoms = NULL;
int error;
ButtonPressMask /* SCROLL; on X mouse wheel events is treated as mouse button 4/5 */
};
-const gint _gdk_x11_event_mask_table_size = G_N_ELEMENTS (_gdk_x11_event_mask_table);
+const int _gdk_x11_event_mask_table_size = G_N_ELEMENTS (_gdk_x11_event_mask_table);
/* Forward declarations */
static void gdk_x11_surface_apply_fullscreen_mode (GdkSurface *surface);
Window xwindow = GDK_SURFACE_XID (surface);
GdkToplevelX11 *toplevel;
Atom atoms[9];
- gint i;
+ int i;
toplevel = _gdk_x11_surface_get_toplevel (surface);
static inline void
x11_surface_move (GdkSurface *surface,
- gint x,
- gint y)
+ int x,
+ int y)
{
GdkX11Surface *impl = GDK_X11_SURFACE (surface);
static inline void
x11_surface_resize (GdkSurface *surface,
- gint width,
- gint height)
+ int width,
+ int height)
{
GdkX11Surface *impl = GDK_X11_SURFACE (surface);
static inline void
x11_surface_move_resize (GdkSurface *surface,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
GdkX11Surface *impl = GDK_X11_SURFACE (surface);
static void
gdk_x11_surface_move_resize (GdkSurface *surface,
gboolean with_move,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
if (with_move && (width < 0 && height < 0))
x11_surface_move (surface, x, y);
static void
gdk_x11_surface_toplevel_resize (GdkSurface *surface,
- gint width,
- gint height)
+ int width,
+ int height)
{
x11_surface_resize (surface, width, height);
}
void
gdk_x11_surface_move (GdkSurface *surface,
- gint x,
- gint y)
+ int x,
+ int y)
{
gdk_x11_surface_move_resize (surface, TRUE, x, y, -1, -1);
}
GdkX11Screen *x11_screen = GDK_SURFACE_SCREEN (surface);
guint32 prop = 0;
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
guchar *data;
{
gchar *prop_text = NULL;
Atom prop_type;
- gint prop_length;
- gint prop_format;
+ int prop_length;
+ int prop_format;
gboolean is_compound_text;
if (utf8_is_latin1 (utf8_str))
static void
gdk_x11_surface_get_geometry (GdkSurface *surface,
- gint *x,
- gint *y,
- gint *width,
- gint *height)
+ int *x,
+ int *y,
+ int *width,
+ int *height)
{
GdkX11Surface *impl;
Window root;
- gint tx;
- gint ty;
+ int tx;
+ int ty;
guint twidth;
guint theight;
guint tborder_width;
void
gdk_x11_surface_get_root_coords (GdkSurface *surface,
- gint x,
- gint y,
- gint *root_x,
- gint *root_y)
+ int x,
+ int y,
+ int *root_x,
+ int *root_y)
{
GdkX11Surface *impl = GDK_X11_SURFACE (surface);
Window child;
- gint tx;
- gint ty;
+ int tx;
+ int ty;
XTranslateCoordinates (GDK_SURFACE_XDISPLAY (surface),
GDK_SURFACE_XID (surface),
guint nvroots;
gulong nitems_return;
gulong bytes_after_return;
- gint format_return;
- gint i;
+ int format_return;
+ int i;
guint ww, wh, wb, wd;
- gint wx, wy;
+ int wx, wy;
gboolean got_frame_extents = FALSE;
g_return_if_fail (rect != NULL);
}
else
{
- gint n_rects = 0;
+ int n_rects = 0;
XRectangle *xrects = NULL;
_gdk_x11_region_get_xrectangles (input_region,
{
gulong *data;
gulong *p;
- gint size;
+ int size;
GList *l;
- gint width, height;
+ int width, height;
GdkTexture *texture;
GdkDisplay *display;
- gint i, n;
+ int i, n;
if (GDK_SURFACE_DESTROYED (surface))
return;
if (GDK_SURFACE_IS_MAPPED (surface))
{
XClientMessageEvent xclient;
- gint monitors[4];
- gint i;
+ int monitors[4];
+ int i;
memset (&xclient, 0, sizeof (xclient));
xclient.type = ClientMessage;
Atom hints_atom = None;
guchar *data;
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
guchar *data;
MotifWmHints *hints;
Atom type;
- gint format;
+ int format;
gulong nitems;
gulong bytes_after;
cairo_region_t *
_gdk_x11_xwindow_get_shape (Display *xdisplay,
Window window,
- gint scale,
- gint shape_type)
+ int scale,
+ int shape_type)
{
cairo_region_t *shape;
GdkRectangle *rl;
XRectangle *xrl;
- gint rn, ord, i;
+ int rn, ord, i;
shape = NULL;
rn = 0;
static void
wmspec_send_message (GdkDisplay *display,
GdkSurface *surface,
- gint root_x,
- gint root_y,
- gint action,
- gint button)
+ int root_x,
+ int root_y,
+ int action,
+ int button)
{
GdkX11Surface *impl = GDK_X11_SURFACE (surface);
XClientMessageEvent xclient;
static void
wmspec_moveresize (GdkSurface *surface,
- gint direction,
+ int direction,
GdkDevice *device,
- gint button,
- gint root_x,
- gint root_y,
+ int button,
+ int root_x,
+ int root_y,
guint32 timestamp)
{
GdkDisplay *display = GDK_SURFACE_DISPLAY (surface);
wmspec_resize_drag (GdkSurface *surface,
GdkSurfaceEdge edge,
GdkDevice *device,
- gint button,
- gint root_x,
- gint root_y,
+ int button,
+ int root_x,
+ int root_y,
guint32 timestamp)
{
- gint direction;
+ int direction;
if (button == 0)
direction = _NET_WM_MOVERESIZE_SIZE_KEYBOARD;
gboolean is_resize;
GdkSurfaceEdge resize_edge;
GdkDevice *device;
- gint moveresize_button;
- gint moveresize_x;
- gint moveresize_y;
- gint moveresize_orig_x;
- gint moveresize_orig_y;
- gint moveresize_orig_width;
- gint moveresize_orig_height;
+ int moveresize_button;
+ int moveresize_x;
+ int moveresize_y;
+ int moveresize_orig_x;
+ int moveresize_orig_y;
+ int moveresize_orig_width;
+ int moveresize_orig_height;
GdkSurfaceHints moveresize_geom_mask;
GdkGeometry moveresize_geometry;
Time moveresize_process_time;
gdouble y_root)
{
GdkSurfaceState state;
- gint y;
+ int y;
if (mv_resize->is_resize)
return;
gdouble y_root)
{
GdkSurfaceState state;
- gint dx, dy;
+ int dx, dy;
if (mv_resize->is_resize)
return;
static void
update_pos (MoveResizeData *mv_resize,
- gint new_root_x,
- gint new_root_y)
+ int new_root_x,
+ int new_root_y)
{
- gint dx, dy;
+ int dx, dy;
check_unmaximize (mv_resize, new_root_x, new_root_y);
dx = new_root_x - mv_resize->moveresize_x;
if (mv_resize->is_resize)
{
- gint x, y, w, h;
+ int x, y, w, h;
x = mv_resize->moveresize_orig_x;
y = mv_resize->moveresize_orig_y;
}
else
{
- gint x, y;
+ int x, y;
x = mv_resize->moveresize_orig_x + dx;
y = mv_resize->moveresize_orig_y + dy;
/* we just assume this is an XI2 event */
XIEvent *ev = (XIEvent *) event->xcookie.data;
XIDeviceEvent *xev = (XIDeviceEvent *)ev;
- gint state;
+ int state;
switch (ev->evtype)
{
case XI_Motion:
calculate_unmoving_origin (MoveResizeData *mv_resize)
{
GdkRectangle rect;
- gint width, height;
+ int width, height;
if (mv_resize->moveresize_geom_mask & GDK_HINT_WIN_GRAVITY &&
mv_resize->moveresize_geometry.win_gravity == GDK_GRAVITY_STATIC)
emulate_resize_drag (GdkSurface *surface,
GdkSurfaceEdge edge,
GdkDevice *device,
- gint button,
- gint root_x,
- gint root_y,
+ int button,
+ int root_x,
+ int root_y,
guint32 timestamp)
{
MoveResizeData *mv_resize = get_move_resize_data (GDK_SURFACE_DISPLAY (surface), TRUE);
static void
emulate_move_drag (GdkSurface *surface,
GdkDevice *device,
- gint button,
- gint root_x,
- gint root_y,
+ int button,
+ int root_x,
+ int root_y,
guint32 timestamp)
{
MoveResizeData *mv_resize = get_move_resize_data (GDK_SURFACE_DISPLAY (surface), TRUE);
{
GdkSurface *surface = GDK_SURFACE (toplevel);
int root_x, root_y;
- gint direction;
+ int direction;
if (GDK_SURFACE_DESTROYED (surface))
return;
return GDK_X11_SURFACE (surface)->xid;
}
-static gint
+static int
gdk_x11_surface_get_scale_factor (GdkSurface *surface)
{
GdkX11Surface *impl = GDK_X11_SURFACE (surface);
guint frame_sync_enabled : 1;
guint tracking_damage: 1;
- gint surface_scale;
+ int surface_scale;
/* Width and height not divided by surface_scale - this matters in the
* corner-case where the window manager assigns us a size that isn't
* a multiple of surface_scale - for example for a maximized window
* with an odd-sized title-bar.
*/
- gint unscaled_width;
- gint unscaled_height;
+ int unscaled_width;
+ int unscaled_height;
cairo_surface_t *cairo_surface;
void gdk_x11_surface_pre_damage (GdkSurface *surface);
void gdk_x11_surface_move (GdkSurface *surface,
- gint x,
- gint y);
+ int x,
+ int y);
void gdk_x11_surface_check_monitor (GdkSurface *surface,
GdkMonitor *monitor);
GdkDisplay *display;
const char *encoding; /* interned */
- gint format;
+ int format;
guint encoder : 1;
};
gsize *bytes_written,
GError **error)
{
- gint count;
+ int count;
char **list;
if (!(flags & G_CONVERTER_INPUT_AT_END))
gdk_x11_utf8_to_string_target (const char *utf8_str,
gboolean return_latin1)
{
- gint len = strlen (utf8_str);
+ int len = strlen (utf8_str);
GString *result = g_string_sized_new (len);
const gchar *p = utf8_str;
else
{
char buf[7];
- gint buflen;
+ int buflen;
buflen = g_unichar_to_utf8 (ch, buf);
g_string_append_len (result, buf, buflen);
GConverterResult result;
guchar *text;
const char *encoding;
- gint format;
- gint new_length;
+ int format;
+ int new_length;
char *tmp;
tmp = g_strndup (inbuf, inbuf_size);
_gdk_x11_screen_init_visuals (GdkX11Screen *x11_screen,
gboolean setup_display)
{
- static const gint possible_depths[8] = { 32, 30, 24, 16, 15, 8, 4, 1 };
+ static const int possible_depths[8] = { 32, 30, 24, 16, 15, 8, 4, 1 };
static const GdkVisualType possible_types[6] =
{
GDK_VISUAL_DIRECT_COLOR,
GObject parent_instance;
GdkVisualType type;
- gint depth;
+ int depth;
GdkByteOrder byte_order;
- gint colormap_size;
- gint bits_per_rgb;
+ int colormap_size;
+ int bits_per_rgb;
guint32 red_mask;
guint32 green_mask;
G_BEGIN_DECLS
GDK_AVAILABLE_IN_ALL
-gint gdk_x11_device_get_id (GdkDevice *device);
+int gdk_x11_device_get_id (GdkDevice *device);
G_END_DECLS
GDK_AVAILABLE_IN_ALL
GdkDevice * gdk_x11_device_manager_lookup (GdkX11DeviceManagerXI2 *device_manager,
- gint device_id);
+ int device_id);
G_END_DECLS
GDK_AVAILABLE_IN_ALL
void gdk_x11_display_set_cursor_theme (GdkDisplay *display,
const gchar *theme,
- const gint size);
+ const int size);
GDK_AVAILABLE_IN_ALL
void gdk_x11_display_broadcast_startup_message (GdkDisplay *display,
GDK_AVAILABLE_IN_ALL
void gdk_x11_display_set_surface_scale (GdkDisplay *display,
- gint scale);
+ int scale);
GDK_AVAILABLE_IN_ALL
void gdk_x11_display_error_trap_push (GdkDisplay *display);
/* warn unused because you could use pop_ignored otherwise */
GDK_AVAILABLE_IN_ALL
-G_GNUC_WARN_UNUSED_RESULT gint gdk_x11_display_error_trap_pop (GdkDisplay *display);
+G_GNUC_WARN_UNUSED_RESULT int gdk_x11_display_error_trap_pop (GdkDisplay *display);
GDK_AVAILABLE_IN_ALL
void gdk_x11_display_error_trap_pop_ignored (GdkDisplay *display);
GDK_AVAILABLE_IN_ALL
gboolean gdk_x11_display_get_glx_version (GdkDisplay *display,
- gint *major,
- gint *minor);
+ int *major,
+ int *minor);
G_END_DECLS
GDK_AVAILABLE_IN_ALL
XID gdk_x11_screen_get_monitor_output (GdkX11Screen *screen,
- gint monitor_num);
+ int monitor_num);
GDK_AVAILABLE_IN_ALL
guint32 gdk_x11_screen_get_number_of_desktops (GdkX11Screen *screen);
G_BEGIN_DECLS
GDK_AVAILABLE_IN_ALL
-gint gdk_x11_display_text_property_to_text_list (GdkDisplay *display,
+int gdk_x11_display_text_property_to_text_list (GdkDisplay *display,
const char *encoding,
- gint format,
+ int format,
const guchar *text,
- gint length,
+ int length,
gchar ***list);
GDK_AVAILABLE_IN_ALL
void gdk_x11_free_text_list (gchar **list);
GDK_AVAILABLE_IN_ALL
-gint gdk_x11_display_string_to_compound_text (GdkDisplay *display,
+int gdk_x11_display_string_to_compound_text (GdkDisplay *display,
const char *str,
const char **encoding,
- gint *format,
+ int *format,
guchar **ctext,
- gint *length);
+ int *length);
GDK_AVAILABLE_IN_ALL
gboolean gdk_x11_display_utf8_to_compound_text (GdkDisplay *display,
const char *str,
const char **encoding,
- gint *format,
+ int *format,
guchar **ctext,
- gint *length);
+ int *length);
GDK_AVAILABLE_IN_ALL
void gdk_x11_free_compound_text (guchar *ctext);
#include <gdkscreen-x11.h>
#include <gdkprivate-x11.h>
-static gint
+static int
parse_boolean (char *v)
{
gchar c0, c1;
{
Display *dpy = GDK_SCREEN_XDISPLAY (x11_screen);
gchar *v;
- gint i;
+ int i;
if (GDK_DISPLAY_DEBUG_CHECK (GDK_SCREEN_DISPLAY (x11_screen), DEFAULT_SETTINGS))
return FALSE;
static gboolean
get_integer_default (GdkX11Screen *x11_screen,
const gchar *option,
- gint *value)
+ int *value)
{
Display *dpy = GDK_SCREEN_XDISPLAY (x11_screen);
gchar *v, *e;
{
int width, height, src_rowstride, dest_rowstride, n_channels;
guchar *p_src, *p_dest, *c1, *c2;
- gint x, y, i, i1, i2, width_minus_1, height_minus_1, radius_plus_1;
- gint r, g, b, a;
+ int x, y, i, i1, i2, width_minus_1, height_minus_1, radius_plus_1;
+ int r, g, b, a;
guchar *p_dest_row, *p_dest_col;
width = cairo_image_surface_get_width (src);
GskVulkanRenderer *self)
{
GdkSurface *window;
- gint scale_factor;
+ int scale_factor;
gsize width, height;
guint i;
int i;
guint count;
guint texture_index;
- gint x_position;
+ int x_position;
GskVulkanRenderer *renderer = GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render));
if (has_color_glyphs)
static AtkActionIface *parent_action_iface;
-static gint
+static int
gtk_boolean_cell_accessible_get_n_actions (AtkAction *action)
{
return parent_action_iface->get_n_actions (action) + 1;
static const gchar *
gtk_boolean_cell_accessible_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Toggles the cell");
static const gchar *
gtk_boolean_cell_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "toggle";
static const gchar *
gtk_boolean_cell_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Toggle");
static gboolean
gtk_boolean_cell_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return parent_action_iface->do_action (action, 2);
return name;
}
-static gint
+static int
gtk_button_accessible_get_n_children (AtkObject* obj)
{
return 0;
static AtkObject *
gtk_button_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
return NULL;
}
static gboolean
gtk_button_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_button_accessible_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_button_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
gchar *return_value = NULL;
GtkWidget *widget;
static const gchar *
gtk_button_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "click";
static const gchar *
gtk_button_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Click");
static const gchar *
gtk_button_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Clicks the button");
static void
gtk_button_accessible_get_image_position (AtkImage *image,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
AtkCoordType coord_type)
{
GtkWidget *widget;
static void
gtk_button_accessible_get_image_size (AtkImage *image,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWidget *widget;
GtkWidget *button_image;
G_IMPLEMENT_INTERFACE (ATK_TYPE_COMPONENT, atk_component_interface_init)
G_IMPLEMENT_INTERFACE (ATK_TYPE_TABLE_CELL, atk_table_cell_interface_init))
-static gint
+static int
gtk_cell_accessible_get_index_in_parent (AtkObject *obj)
{
GtkCellAccessible *cell;
return TRUE;
}
-static gint
+static int
gtk_cell_accessible_action_get_n_actions (AtkAction *action)
{
return 3;
static const gchar *
gtk_cell_accessible_action_get_name (AtkAction *action,
- gint index)
+ int index)
{
switch (index)
{
static const gchar *
gtk_cell_accessible_action_get_localized_name (AtkAction *action,
- gint index)
+ int index)
{
switch (index)
{
static const gchar *
gtk_cell_accessible_action_get_description (AtkAction *action,
- gint index)
+ int index)
{
switch (index)
{
static const gchar *
gtk_cell_accessible_action_get_keybinding (AtkAction *action,
- gint index)
+ int index)
{
return NULL;
}
static gboolean
gtk_cell_accessible_action_do_action (AtkAction *action,
- gint index)
+ int index)
{
GtkCellAccessible *cell = GTK_CELL_ACCESSIBLE (action);
GtkCellAccessibleParent *parent;
static void
gtk_cell_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkCellAccessible *cell;
static gboolean
gtk_cell_accessible_get_position (AtkTableCell *table_cell,
- gint *row,
- gint *column)
+ int *row,
+ int *column)
{
GtkCellAccessible *cell;
AtkObject *parent;
void
gtk_cell_accessible_parent_get_cell_extents (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkCellAccessibleParentIface *iface;
void
gtk_cell_accessible_parent_get_cell_position (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *row,
- gint *column)
+ int *row,
+ int *column)
{
GtkCellAccessibleParentIface *iface;
GTypeInterface parent;
void ( *get_cell_extents) (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type);
void ( *get_cell_area) (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
AtkRelationSet *relationset);
void ( *get_cell_position) (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *row,
- gint *column);
+ int *row,
+ int *column);
GPtrArray * ( *get_column_header_cells) (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell);
GPtrArray * ( *get_row_header_cells) (GtkCellAccessibleParent *parent,
GDK_AVAILABLE_IN_ALL
void gtk_cell_accessible_parent_get_cell_extents (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type);
GDK_AVAILABLE_IN_ALL
void gtk_cell_accessible_parent_get_cell_area (GtkCellAccessibleParent *parent,
GDK_AVAILABLE_IN_ALL
void gtk_cell_accessible_parent_get_cell_position(GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *row,
- gint *column);
+ int *row,
+ int *column);
GDK_AVAILABLE_IN_ALL
GPtrArray *gtk_cell_accessible_parent_get_column_header_cells (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell);
ATK_OBJECT (self)->role = ATK_ROLE_RADIO_BUTTON;
}
-static gint
+static int
gtk_color_swatch_accessible_get_n_actions (AtkAction *action)
{
return 3;
static const gchar *
gtk_color_swatch_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
return NULL;
}
static const gchar *
gtk_color_swatch_accessible_get_name (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static const gchar *
gtk_color_swatch_accessible_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static const gchar *
gtk_color_swatch_accessible_get_description (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static gboolean
gtk_color_swatch_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
struct _GtkComboBoxAccessiblePrivate
{
gchar *name;
- gint old_selection;
+ int old_selection;
gboolean popup_set;
};
GtkComboBox *combo_box;
AtkObject *obj;
GtkComboBoxAccessible *accessible;
- gint index;
+ int index;
combo_box = GTK_COMBO_BOX (widget);
GtkTreeIter iter;
const gchar *name;
GtkTreeModel *model;
- gint n_columns;
- gint i;
+ int n_columns;
+ int i;
name = ATK_OBJECT_CLASS (gtk_combo_box_accessible_parent_class)->get_name (obj);
if (name)
return accessible->priv->name;
}
-static gint
+static int
gtk_combo_box_accessible_get_n_children (AtkObject* obj)
{
- gint n_children = 0;
+ int n_children = 0;
GtkWidget *widget;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
static AtkObject *
gtk_combo_box_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
GtkWidget *widget;
AtkObject *child;
static gboolean
gtk_combo_box_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkComboBox *combo_box;
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_combo_box_accessible_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_combo_box_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
GtkComboBoxAccessible *combo_box;
GtkWidget *widget;
static const gchar *
gtk_combo_box_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "press";
static const gchar *
gtk_combo_box_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Press");
static const gchar *
gtk_combo_box_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Presses the combobox");
static gboolean
gtk_combo_box_accessible_add_selection (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
static AtkObject *
gtk_combo_box_accessible_ref_selection (AtkSelection *selection,
- gint i)
+ int i)
{
GtkComboBox *combo_box;
GtkWidget *widget;
AtkObject *obj;
- gint index;
+ int index;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return atk_object_ref_accessible_child (obj, index);
}
-static gint
+static int
gtk_combo_box_accessible_get_selection_count (AtkSelection *selection)
{
GtkWidget *widget;
static gboolean
gtk_combo_box_accessible_is_child_selected (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
- gint j;
+ int j;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
static gboolean
gtk_combo_box_accessible_remove_selection (AtkSelection *selection,
- gint i)
+ int i)
{
if (atk_selection_is_child_selected (selection, i))
atk_selection_clear_selection (selection);
struct _GtkContainerCellAccessiblePrivate
{
GList *children;
- gint n_children;
+ int n_children;
};
G_DEFINE_TYPE_WITH_PRIVATE (GtkContainerCellAccessible, gtk_container_cell_accessible, GTK_TYPE_CELL_ACCESSIBLE)
}
-static gint
+static int
gtk_container_cell_accessible_get_n_children (AtkObject *obj)
{
GtkContainerCellAccessible *cell = GTK_CONTAINER_CELL_ACCESSIBLE (obj);
static AtkObject *
gtk_container_cell_accessible_ref_child (AtkObject *obj,
- gint child)
+ int child)
{
GtkContainerCellAccessible *cell = GTK_CONTAINER_CELL_ACCESSIBLE (obj);
GList *l;
struct _GtkEntryAccessiblePrivate
{
- gint cursor_position;
- gint selection_bound;
+ int cursor_position;
+ int selection_bound;
AtkObject *icons[2];
};
static gboolean
gtk_entry_icon_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkEntryIconAccessible *icon = (GtkEntryIconAccessible *)action;
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_entry_icon_accessible_get_n_actions (AtkAction *action)
{
GtkEntryIconAccessible *icon = GTK_ENTRY_ICON_ACCESSIBLE (action);
static const gchar *
gtk_entry_icon_accessible_get_name (AtkAction *action,
- gint i)
+ int i)
{
GtkEntryIconAccessible *icon = GTK_ENTRY_ICON_ACCESSIBLE (action);
GtkWidget *widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (icon->entry));
static void
gtk_entry_icon_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkEntryIconAccessible *icon = GTK_ENTRY_ICON_ACCESSIBLE (component);
static void
gtk_entry_icon_accessible_get_position (AtkComponent *component,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
AtkCoordType coord_type)
{
GtkEntryIconAccessible *icon = GTK_ENTRY_ICON_ACCESSIBLE (component);
static void
gtk_entry_icon_accessible_get_size (AtkComponent *component,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkEntryIconAccessible *icon = GTK_ENTRY_ICON_ACCESSIBLE (component);
GdkRectangle icon_area;
GtkEditable *editable)
{
gboolean ret_val = FALSE;
- gint start, end;
+ int start, end;
if (gtk_editable_get_selection_bounds (editable, &start, &end))
{
static void
insert_text_cb (GtkEditable *editable,
gchar *new_text,
- gint new_text_length,
- gint *position,
+ int new_text_length,
+ int *position,
GtkEntryAccessible *self)
{
int length;
*/
static void
delete_text_cb (GtkEditable *editable,
- gint start,
- gint end,
+ int start,
+ int end,
GtkEntryAccessible *self)
{
GtkText *textw;
}
else if (g_strcmp0 (pspec->name, "secondary-icon-storage-type") == 0)
{
- gint index = (priv->icons[GTK_ENTRY_ICON_PRIMARY] ? 1 : 0);
+ int index = (priv->icons[GTK_ENTRY_ICON_PRIMARY] ? 1 : 0);
if (gtk_entry_get_icon_storage_type (GTK_ENTRY (widget), GTK_ENTRY_ICON_SECONDARY) != GTK_IMAGE_EMPTY &&
!priv->icons[GTK_ENTRY_ICON_SECONDARY])
{
{
GtkWidget *widget;
GtkEntryAccessible *gtk_entry_accessible;
- gint start_pos, end_pos;
+ int start_pos, end_pos;
ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->initialize (obj, data);
g_signal_connect (widget, "notify", G_CALLBACK (on_notify), obj);
}
-static gint
+static int
gtk_entry_accessible_get_index_in_parent (AtkObject *accessible)
{
/*
return ATK_OBJECT_CLASS (gtk_entry_accessible_parent_class)->get_index_in_parent (accessible);
}
-static gint
+static int
gtk_entry_accessible_get_n_children (AtkObject* obj)
{
GtkWidget *widget;
- gint count = 0;
+ int count = 0;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
static AtkObject *
gtk_entry_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
GtkEntryAccessible *accessible = GTK_ENTRY_ACCESSIBLE (obj);
GtkEntryAccessiblePrivate *priv = accessible->priv;
static gchar *
gtk_entry_accessible_get_text (AtkText *atk_text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkText *text;
static gchar *
gtk_entry_accessible_get_text_before_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkText *text;
static gchar *
gtk_entry_accessible_get_text_at_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkText *text;
static gchar *
gtk_entry_accessible_get_text_after_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkText *text;
start_offset, end_offset);
}
-static gint
+static int
gtk_entry_accessible_get_character_count (AtkText *atk_text)
{
GtkText *text;
return char_count;
}
-static gint
+static int
gtk_entry_accessible_get_caret_offset (AtkText *text)
{
GtkWidget *widget;
static gboolean
gtk_entry_accessible_set_caret_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkWidget *widget;
static AtkAttributeSet *
add_text_attribute (AtkAttributeSet *attributes,
AtkTextAttribute attr,
- gint i)
+ int i)
{
AtkAttribute *at;
static AtkAttributeSet *
gtk_entry_accessible_get_run_attributes (AtkText *atk_text,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
GtkText *text;
AtkAttributeSet *attributes;
static void
gtk_entry_accessible_get_character_extents (AtkText *atk_text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords)
{
GtkText *textw;
PangoRectangle char_rect;
gchar *entry_text;
- gint index, x_layout, y_layout;
+ int index, x_layout, y_layout;
GtkAllocation allocation;
textw = get_text (atk_text);
*height = char_rect.height;
}
-static gint
+static int
gtk_entry_accessible_get_offset_at_point (AtkText *atk_text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
GtkText *textw;
gchar *text;
- gint index, x_layout, y_layout;
- gint x_local, y_local;
+ int index, x_layout, y_layout;
+ int x_local, y_local;
glong offset;
textw = get_text (atk_text);
return offset;
}
-static gint
+static int
gtk_entry_accessible_get_n_selections (AtkText *text)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gchar *
gtk_entry_accessible_get_selection (AtkText *text,
- gint selection_num,
- gint *start_pos,
- gint *end_pos)
+ int selection_num,
+ int *start_pos,
+ int *end_pos)
{
GtkWidget *widget;
static gboolean
gtk_entry_accessible_add_selection (AtkText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkEntry *entry;
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_entry_accessible_remove_selection (AtkText *text,
- gint selection_num)
+ int selection_num)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_entry_accessible_set_selection (AtkText *text,
- gint selection_num,
- gint start_pos,
- gint end_pos)
+ int selection_num,
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gunichar
gtk_entry_accessible_get_character_at_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkText *textw;
gchar *text;
static void
gtk_entry_accessible_insert_text (AtkEditableText *text,
const gchar *string,
- gint length,
- gint *position)
+ int length,
+ int *position)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_entry_accessible_copy_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_entry_accessible_cut_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_entry_accessible_delete_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
typedef struct
{
GtkEntry* entry;
- gint position;
+ int position;
} PasteData;
static void
static void
gtk_entry_accessible_paste_text (AtkEditableText *text,
- gint position)
+ int position)
{
GtkWidget *widget;
GtkEditable *editable;
static gboolean
gtk_entry_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_entry_accessible_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_entry_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkWidget *label;
static const gchar*
gtk_entry_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "activate";
static const gchar*
gtk_entry_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Activate");
static const gchar*
gtk_entry_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Activates the entry");
return gtk_expander_accessible_get_full_text (GTK_EXPANDER (widget));
}
-static gint
+static int
gtk_expander_accessible_get_n_children (AtkObject *obj)
{
GtkWidget *widget;
static AtkObject *
gtk_expander_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
AtkObject *accessible;
GtkWidget *widget;
static gboolean
gtk_expander_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_expander_accessible_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_expander_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
gchar *return_value = NULL;
GtkWidget *widget;
static const gchar *
gtk_expander_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "activate";
static const gchar *
gtk_expander_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Activate");
static const gchar *
gtk_expander_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Activates the expander");
static gboolean
gtk_flow_box_accessible_add_selection (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
GtkWidget *child;
static gboolean
gtk_flow_box_accessible_remove_selection (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
GtkWidget *child;
typedef struct
{
- gint idx;
+ int idx;
GtkWidget *child;
} FindSelectedData;
static AtkObject *
gtk_flow_box_accessible_ref_selection (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
AtkObject *accessible;
GtkFlowBoxChild *child,
gpointer data)
{
- gint *count = data;
+ int *count = data;
*count += 1;
}
-static gint
+static int
gtk_flow_box_accessible_get_selection_count (AtkSelection *selection)
{
GtkWidget *box;
- gint count;
+ int count;
box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (box == NULL)
static gboolean
gtk_flow_box_accessible_is_child_selected (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
GtkFlowBoxChild *child;
static gboolean
gtk_icon_view_item_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkIconViewItemAccessible *item;
return TRUE;
}
-static gint
+static int
gtk_icon_view_item_accessible_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_icon_view_item_accessible_get_description (AtkAction *action,
- gint i)
+ int i)
{
GtkIconViewItemAccessible *item;
static const gchar *
gtk_icon_view_item_accessible_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i != 0)
return NULL;
static gboolean
gtk_icon_view_item_accessible_set_description (AtkAction *action,
- gint i,
+ int i,
const gchar *description)
{
GtkIconViewItemAccessible *item;
static void
gtk_icon_view_item_accessible_get_image_size (AtkImage *image,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkIconViewItemAccessible *item;
GdkRectangle box;
static void
gtk_icon_view_item_accessible_get_image_position (AtkImage *image,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
static gchar *
gtk_icon_view_item_accessible_get_text (AtkText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkIconViewItemAccessible *item;
static gunichar
gtk_icon_view_item_accessible_get_character_at_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkIconViewItemAccessible *item;
gchar *string;
static gchar *
gtk_icon_view_item_accessible_get_text_before_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkIconViewItemAccessible *item;
PangoLayout *layout;
static gchar *
gtk_icon_view_item_accessible_get_text_at_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkIconViewItemAccessible *item;
PangoLayout *layout;
static gchar *
gtk_icon_view_item_accessible_get_text_after_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkIconViewItemAccessible *item;
PangoLayout *layout;
return text;
}
-static gint
+static int
gtk_icon_view_item_accessible_get_character_count (AtkText *text)
{
GtkIconViewItemAccessible *item;
static void
gtk_icon_view_item_accessible_get_character_extents (AtkText *text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
GtkIconView *icon_view;
PangoRectangle char_rect;
const gchar *item_text;
- gint index;
+ int index;
#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
#endif
}
-static gint
+static int
gtk_icon_view_item_accessible_get_offset_at_point (AtkText *text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
- gint offset = 0;
+ int offset = 0;
#if 0
GtkIconView *icon_view;
const gchar *item_text;
- gint index;
- gint l_x, l_y;
+ int index;
+ int l_x, l_y;
#endif
item = GTK_ICON_VIEW_ITEM_ACCESSIBLE (text);
static void
gtk_icon_view_item_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkIconViewItemAccessible *item;
AtkObject *parent_obj;
- gint l_x, l_y;
+ int l_x, l_y;
g_return_if_fail (GTK_IS_ICON_VIEW_ITEM_ACCESSIBLE (component));
return NULL;
}
-static gint
+static int
_gtk_icon_view_item_accessible_get_index_in_parent (AtkObject *obj)
{
GtkIconViewItemAccessible *item;
priv->items = g_list_insert_before (priv->items, items, info);
}
-static gint
+static int
gtk_icon_view_accessible_get_n_children (AtkObject *accessible)
{
GtkIconView *icon_view;
static GtkIconViewItemAccessible *
gtk_icon_view_accessible_find_child (GtkIconViewAccessible *self,
- gint index)
+ int index)
{
GtkIconViewAccessiblePrivate *priv = gtk_icon_view_accessible_get_instance_private (self);
GList *items;
static AtkObject *
gtk_icon_view_accessible_ref_child (AtkObject *accessible,
- gint index)
+ int index)
{
GtkIconViewAccessible *self = GTK_ICON_VIEW_ACCESSIBLE (accessible);
GtkIconViewItemAccessible *a11y_item;
gtk_icon_view_accessible_traverse_items (self, tmp_list);
}
-static gint
+static int
gtk_icon_view_accessible_item_compare (ItemAccessibleInfo *i1,
ItemAccessibleInfo *i2)
{
gtk_icon_view_accessible_model_rows_reordered (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer user_data)
{
GtkIconViewAccessible *self = user_data;
static AtkObject*
gtk_icon_view_accessible_ref_accessible_at_point (AtkComponent *component,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coord_type)
{
GtkWidget *widget;
GtkIconView *icon_view;
GtkIconViewItem *item;
- gint x_pos, y_pos;
+ int x_pos, y_pos;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (component));
if (widget == NULL)
static gboolean
gtk_icon_view_accessible_add_selection (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkIconView *icon_view;
static AtkObject*
gtk_icon_view_accessible_ref_selection (AtkSelection *selection,
- gint i)
+ int i)
{
GList *l;
GtkWidget *widget;
return NULL;
}
-static gint
+static int
gtk_icon_view_accessible_get_selection_count (AtkSelection *selection)
{
GtkWidget *widget;
GtkIconView *icon_view;
GtkIconViewItem *item;
GList *l;
- gint count;
+ int count;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
static gboolean
gtk_icon_view_accessible_is_child_selected (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkIconView *icon_view;
static gboolean
gtk_icon_view_accessible_remove_selection (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkIconView *icon_view;
GtkIconViewItem *item;
GList *l;
- gint count;
+ int count;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
{
gchar *name;
const gchar *label;
- gint i;
+ int i;
name = g_strdup (icon_name);
if (g_str_has_suffix (name, "-symbolic"))
static void
gtk_image_accessible_get_image_position (AtkImage *image,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
AtkCoordType coord_type)
{
atk_component_get_extents (ATK_COMPONENT (image), x, y, NULL, NULL,
static void
gtk_image_accessible_get_image_size (AtkImage *image,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWidget* widget;
GtkImage *gtk_image;
static void
gtk_image_cell_accessible_get_image_position (AtkImage *image,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
AtkCoordType coord_type)
{
atk_component_get_extents (ATK_COMPONENT (image), x, y, NULL, NULL,
static void
gtk_image_cell_accessible_get_image_size (AtkImage *image,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkImageCellAccessible *cell = GTK_IMAGE_CELL_ACCESSIBLE (image);
GtkCellRenderer *cell_renderer;
struct _GtkLabelAccessiblePrivate
{
- gint cursor_position;
- gint selection_bound;
+ int cursor_position;
+ int selection_bound;
GList *links;
};
AtkHyperlink parent;
GtkLabelAccessible *label;
- gint index;
+ int index;
gboolean focused;
};
};
static GtkLabelAccessibleLink *gtk_label_accessible_link_new (GtkLabelAccessible *label,
- gint idx);
+ int idx);
typedef struct _GtkLabelAccessibleLinkImpl GtkLabelAccessibleLinkImpl;
typedef struct _GtkLabelAccessibleLinkImplClass GtkLabelAccessibleLinkImplClass;
static GtkLabelAccessibleLinkImpl *
gtk_label_accessible_link_impl_new (GtkLabelAccessible *label,
- gint idx)
+ int idx)
{
GtkLabelAccessibleLinkImpl *impl;
static gchar *
gtk_label_accessible_link_get_uri (AtkHyperlink *atk_link,
- gint i)
+ int i)
{
GtkLabelAccessibleLink *link = (GtkLabelAccessibleLink *)atk_link;
GtkWidget *widget;
return g_strdup (uri);
}
-static gint
+static int
gtk_label_accessible_link_get_n_anchors (AtkHyperlink *atk_link)
{
return 1;
static AtkObject *
gtk_label_accessible_link_get_object (AtkHyperlink *atk_link,
- gint i)
+ int i)
{
GtkLabelAccessibleLink *link = (GtkLabelAccessibleLink *)atk_link;
return ATK_OBJECT (link->label);
}
-static gint
+static int
gtk_label_accessible_link_get_start_index (AtkHyperlink *atk_link)
{
GtkLabelAccessibleLink *link = (GtkLabelAccessibleLink *)atk_link;
GtkWidget *widget;
- gint start, end;
+ int start, end;
if (link->label == NULL)
return 0;
return start;
}
-static gint
+static int
gtk_label_accessible_link_get_end_index (AtkHyperlink *atk_link)
{
GtkLabelAccessibleLink *link = (GtkLabelAccessibleLink *)atk_link;
GtkWidget *widget;
- gint start, end;
+ int start, end;
if (link->label == NULL)
return 0;
static GtkLabelAccessibleLink *
gtk_label_accessible_link_new (GtkLabelAccessible *label,
- gint idx)
+ int idx)
{
GtkLabelAccessibleLink *link;
static gboolean
gtk_label_accessible_link_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkLabelAccessibleLink *link = (GtkLabelAccessibleLink *)action;
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_label_accessible_link_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_label_accessible_link_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i != 0)
return NULL;
GtkLabel *label)
{
gboolean ret_val = FALSE;
- gint start, end;
+ int start, end;
if (gtk_label_get_selection_bounds (label, &start, &end))
{
}
}
-static gint
+static int
gtk_label_accessible_get_n_children (AtkObject *obj)
{
GtkLabelAccessible *accessible = GTK_LABEL_ACCESSIBLE (obj);
static AtkObject *
gtk_label_accessible_ref_child (AtkObject *obj,
- gint idx)
+ int idx)
{
GtkLabelAccessible *accessible = GTK_LABEL_ACCESSIBLE (obj);
AtkObject *child;
clear_links (GtkLabelAccessible *accessible)
{
GList *l;
- gint i;
+ int i;
GtkLabelAccessibleLinkImpl *impl;
for (l = accessible->priv->links, i = 0; l; l = l->next, i++)
create_links (GtkLabelAccessible *accessible)
{
GtkWidget *widget;
- gint n, i;
+ int n, i;
GtkLabelAccessibleLinkImpl *impl;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
static gchar*
gtk_label_accessible_get_text (AtkText *atk_text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
const gchar *text;
static gchar *
gtk_label_accessible_get_text_before_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
static gchar*
gtk_label_accessible_get_text_at_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
static gchar*
gtk_label_accessible_get_text_after_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
start_offset, end_offset);
}
-static gint
+static int
gtk_label_accessible_get_character_count (AtkText *atk_text)
{
GtkWidget *widget;
return 0;
}
-static gint
+static int
gtk_label_accessible_get_caret_offset (AtkText *text)
{
GtkWidget *widget;
static gboolean
gtk_label_accessible_set_caret_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkWidget *widget;
GtkLabel *label;
return TRUE;
}
-static gint
+static int
gtk_label_accessible_get_n_selections (AtkText *text)
{
GtkWidget *widget;
static gchar *
gtk_label_accessible_get_selection (AtkText *atk_text,
- gint selection_num,
- gint *start_pos,
- gint *end_pos)
+ int selection_num,
+ int *start_pos,
+ int *end_pos)
{
GtkWidget *widget;
GtkLabel *label;
static gboolean
gtk_label_accessible_add_selection (AtkText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkLabel *label;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_label_accessible_remove_selection (AtkText *text,
- gint selection_num)
+ int selection_num)
{
GtkWidget *widget;
GtkLabel *label;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_label_accessible_set_selection (AtkText *text,
- gint selection_num,
- gint start_pos,
- gint end_pos)
+ int selection_num,
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkLabel *label;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static void
gtk_label_accessible_get_character_extents (AtkText *text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords)
{
GtkWidget *widget;
GtkLabel *label;
PangoRectangle char_rect;
const gchar *label_text;
- gint index, x_layout, y_layout;
+ int index, x_layout, y_layout;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
*height = char_rect.height;
}
-static gint
+static int
gtk_label_accessible_get_offset_at_point (AtkText *atk_text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
GtkWidget *widget;
GtkLabel *label;
const gchar *text;
- gint index, x_layout, y_layout;
- gint x_local, y_local;
+ int index, x_layout, y_layout;
+ int x_local, y_local;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
if (widget == NULL)
static AtkAttributeSet*
gtk_label_accessible_get_run_attributes (AtkText *text,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
AtkAttributeSet *attributes;
static gunichar
gtk_label_accessible_get_character_at_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkWidget *widget;
const gchar *text;
static AtkHyperlink *
gtk_label_accessible_get_link (AtkHypertext *hypertext,
- gint idx)
+ int idx)
{
GtkLabelAccessible *label = GTK_LABEL_ACCESSIBLE (hypertext);
GtkLabelAccessibleLinkImpl *impl;
return NULL;
}
-static gint
+static int
gtk_label_accessible_get_n_links (AtkHypertext *hypertext)
{
GtkWidget *widget;
return _gtk_label_get_n_links (GTK_LABEL (widget));
}
-static gint
+static int
gtk_label_accessible_get_link_index (AtkHypertext *hypertext,
- gint char_index)
+ int char_index)
{
GtkWidget *widget;
static gchar *
gtk_link_button_accessible_link_get_uri (AtkHyperlink *atk_link,
- gint i)
+ int i)
{
GtkLinkButtonAccessibleLink *l = (GtkLinkButtonAccessibleLink *)atk_link;
GtkWidget *widget;
return g_strdup (uri);
}
-static gint
+static int
gtk_link_button_accessible_link_get_n_anchors (AtkHyperlink *atk_link)
{
return 1;
static AtkObject *
gtk_link_button_accessible_link_get_object (AtkHyperlink *atk_link,
- gint i)
+ int i)
{
GtkLinkButtonAccessibleLink *l = (GtkLinkButtonAccessibleLink *)atk_link;
static gboolean
gtk_link_button_accessible_link_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkLinkButtonAccessibleLink *l = (GtkLinkButtonAccessibleLink *)action;
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_link_button_accessible_link_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_link_button_accessible_link_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i != 0)
return NULL;
static gboolean
gtk_list_box_accessible_add_selection (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
GtkListBoxRow *row;
static gboolean
gtk_list_box_accessible_remove_selection (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
GtkListBoxRow *row;
typedef struct
{
- gint idx;
+ int idx;
GtkWidget *row;
} FindSelectedData;
static AtkObject *
gtk_list_box_accessible_ref_selection (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
AtkObject *accessible;
GtkListBoxRow *row,
gpointer data)
{
- gint *count = data;
+ int *count = data;
*count += 1;
}
-static gint
+static int
gtk_list_box_accessible_get_selection_count (AtkSelection *selection)
{
GtkWidget *box;
- gint count;
+ int count;
box = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (box == NULL)
static gboolean
gtk_list_box_accessible_is_child_selected (AtkSelection *selection,
- gint idx)
+ int idx)
{
GtkWidget *box;
GtkListBoxRow *row;
accessible->role = ATK_ROLE_TOGGLE_BUTTON;
}
-static gint
+static int
gtk_menu_button_accessible_get_n_children (AtkObject* obj)
{
GtkWidget *widget;
- gint count = 0;
+ int count = 0;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
static AtkObject *
gtk_menu_button_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
AtkObject *accessible = NULL;
GtkWidget *widget;
* need to be created
*/
GHashTable * pages;
- gint selected_page;
+ int selected_page;
};
static void atk_selection_interface_init (AtkSelectionIface *iface);
create_notebook_page_accessible (GtkNotebookAccessible *accessible,
GtkNotebook *notebook,
GtkWidget *child,
- gint page_num)
+ int page_num)
{
AtkObject *obj;
{
GtkNotebookAccessible *accessible;
GtkNotebook *notebook;
- gint i;
+ int i;
ATK_OBJECT_CLASS (gtk_notebook_accessible_parent_class)->initialize (obj, data);
static AtkObject *
gtk_notebook_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
AtkObject *child;
GtkNotebookAccessible *accessible;
*/
static gboolean
gtk_notebook_accessible_add_selection (AtkSelection *selection,
- gint i)
+ int i)
{
GtkNotebook *notebook;
GtkWidget *widget;
static AtkObject *
gtk_notebook_accessible_ref_selection (AtkSelection *selection,
- gint i)
+ int i)
{
AtkObject *accessible;
GtkWidget *widget;
GtkNotebook *notebook;
- gint pagenum;
+ int pagenum;
if (i != 0)
return NULL;
/* Always return 1 because there can only be one page
* selected at any time
*/
-static gint
+static int
gtk_notebook_accessible_get_selection_count (AtkSelection *selection)
{
GtkWidget *widget;
static gboolean
gtk_notebook_accessible_is_child_selected (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkNotebook *notebook;
- gint pagenumber;
+ int pagenumber;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
return ATK_OBJECT (page->priv->notebook);
}
-static gint
+static int
gtk_notebook_page_accessible_get_n_children (AtkObject *accessible)
{
return 1;
static AtkObject *
gtk_notebook_page_accessible_ref_child (AtkObject *accessible,
- gint i)
+ int i)
{
AtkObject *child_obj;
GtkNotebookPageAccessible *page = NULL;
return merged_state_set;
}
-static gint
+static int
gtk_notebook_page_accessible_get_index_in_parent (AtkObject *accessible)
{
GtkNotebookPageAccessible *page;
static AtkObject*
gtk_notebook_page_accessible_ref_accessible_at_point (AtkComponent *component,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coord_type)
{
/* There is only one child so we return it */
static void
gtk_notebook_page_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkWidget *label;
GValue *value)
{
GtkWidget* widget;
- gint current_value;
+ int current_value;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
GValue *value)
{
GtkWidget* widget;
- gint maximum_value;
+ int maximum_value;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
GValue *value)
{
GtkWidget* widget;
- gint minimum_value;
+ int minimum_value;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
const GValue *value)
{
GtkWidget* widget;
- gint new_value;
+ int new_value;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
gtk_paned_accessible_get_range (AtkValue *obj)
{
GtkWidget *widget;
- gint minimum_value;
- gint maximum_value;
+ int minimum_value;
+ int maximum_value;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
paned = GTK_PANED (widget);
- gtk_paned_set_position (paned, (gint)(value + 0.5));
+ gtk_paned_set_position (paned, (int)(value + 0.5));
}
static void
static gunichar
gtk_password_entry_accessible_get_character_at_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkText *text;
char *contents, *index;
return result;
}
-static gint
+static int
gtk_password_entry_accessible_get_caret_offset (AtkText *atk_text)
{
GtkWidget *widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
static gboolean
gtk_password_entry_accessible_set_caret_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkWidget *widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
if (widget == NULL)
return TRUE;
}
-static gint
+static int
gtk_password_entry_accessible_get_character_count (AtkText *atk_text)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
return char_count;
}
-static gint
+static int
gtk_password_entry_accessible_get_offset_at_point (AtkText *atk_text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
static void
gtk_password_entry_accessible_insert_text (AtkEditableText *text,
const gchar *string,
- gint length,
- gint *position)
+ int length,
+ int *position)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_password_entry_accessible_delete_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_password_entry_accessible_paste_text (AtkEditableText *text,
- gint position)
+ int position)
{
GtkWidget *widget;
GtkEditable *editable;
static gboolean
gtk_password_entry_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
return FALSE;
}
-static gint
+static int
gtk_password_entry_accessible_get_n_actions (AtkAction *action)
{
GtkAccessible *accessible = GTK_ACCESSIBLE (action);
static const gchar *
gtk_password_entry_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkWidget *label;
static const gchar *
gtk_password_entry_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static const gchar*
gtk_password_entry_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Activate");
static const gchar *
gtk_password_entry_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Activates the entry");
GtkEditable *editable)
{
gboolean ret_val = FALSE;
- gint start, end;
+ int start, end;
if (gtk_editable_get_selection_bounds (editable, &start, &end))
{
static void
insert_text_cb (GtkEditable *editable,
gchar *new_text,
- gint new_text_length,
- gint *position,
+ int new_text_length,
+ int *position,
GtkPasswordEntryAccessible *self)
{
int length;
static void
delete_text_cb (GtkEditable *editable,
- gint start,
- gint end,
+ int start,
+ int end,
GtkPasswordEntryAccessible *self)
{
GtkText *text;
static void
gtk_picture_accessible_get_image_position (AtkImage *image,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
AtkCoordType coord_type)
{
atk_component_get_extents (ATK_COMPONENT (image), x, y, NULL, NULL,
static void
gtk_picture_accessible_get_image_size (AtkImage *image,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWidget* widget;
GdkPaintable *paintable;
AtkObject **accessible_array;
guint list_length;
AtkRelation* relation;
- gint i = 0;
+ int i = 0;
list_length = g_slist_length (list);
accessible_array = g_new (AtkObject *, list_length);
static gboolean
gtk_scale_button_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
}
}
-static gint
+static int
gtk_scale_button_accessible_get_n_actions (AtkAction *action)
{
return 2;
static const gchar *
gtk_scale_button_accessible_get_description (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static const gchar *
gtk_scale_button_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static const gchar *
gtk_scale_button_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
{
if (!g_strcmp0 (pspec->name, "visible"))
{
- gint index;
- gint n_children;
+ int index;
+ int n_children;
gboolean child_added = FALSE;
AtkObject *child;
GtkWidget *widget;
{
GtkWidget *widget;
GtkScrolledWindow *scrolled_window;
- gint n_children;
+ int n_children;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (object));
if (widget == NULL)
static AtkObject *
gtk_scrolled_window_accessible_ref_child (AtkObject *obj,
- gint child)
+ int child)
{
GtkWidget *widget;
GtkScrolledWindow *scrolled_window;
GtkEditable *editable)
{
gboolean ret_val = FALSE;
- gint start, end;
+ int start, end;
if (gtk_editable_get_selection_bounds (editable, &start, &end))
{
static void
insert_text_cb (GtkEditable *editable,
gchar *new_text,
- gint new_text_length,
- gint *position,
+ int new_text_length,
+ int *position,
GtkSearchEntryAccessible *self)
{
int length;
static void
delete_text_cb (GtkEditable *editable,
- gint start,
- gint end,
+ int start,
+ int end,
GtkSearchEntryAccessible *self)
{
GtkText *text;
static gchar *
gtk_search_entry_accessible_get_text (AtkText *atk_text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
static gchar *
gtk_search_entry_accessible_get_text_before_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
static gchar *
gtk_search_entry_accessible_get_text_at_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
static gchar *
gtk_search_entry_accessible_get_text_after_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
start_offset, end_offset);
}
-static gint
+static int
gtk_search_entry_accessible_get_character_count (AtkText *atk_text)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
return char_count;
}
-static gint
+static int
gtk_search_entry_accessible_get_caret_offset (AtkText *atk_text)
{
GtkWidget *widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
static gboolean
gtk_search_entry_accessible_set_caret_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkWidget *widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
if (widget == NULL)
static AtkAttributeSet *
add_text_attribute (AtkAttributeSet *attributes,
AtkTextAttribute attr,
- gint i)
+ int i)
{
AtkAttribute *at;
static AtkAttributeSet *
gtk_search_entry_accessible_get_run_attributes (AtkText *atk_text,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
static void
gtk_search_entry_accessible_get_character_extents (AtkText *atk_text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
*height = char_rect.height;
}
-static gint
+static int
gtk_search_entry_accessible_get_offset_at_point (AtkText *atk_text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
GtkText *text = get_text_widget (GTK_ACCESSIBLE (atk_text));
return offset;
}
-static gint
+static int
gtk_search_entry_accessible_get_n_selections (AtkText *text)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gchar *
gtk_search_entry_accessible_get_selection (AtkText *text,
- gint selection_num,
- gint *start_pos,
- gint *end_pos)
+ int selection_num,
+ int *start_pos,
+ int *end_pos)
{
GtkEditable *editable;
GtkWidget *widget;
static gboolean
gtk_search_entry_accessible_add_selection (AtkText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkEntry *entry;
GtkWidget *widget;
static gboolean
gtk_search_entry_accessible_remove_selection (AtkText *text,
- gint selection_num)
+ int selection_num)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_search_entry_accessible_set_selection (AtkText *text,
- gint selection_num,
- gint start_pos,
- gint end_pos)
+ int selection_num,
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gunichar
gtk_search_entry_accessible_get_character_at_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkText *text;
char *contents;
static void
gtk_search_entry_accessible_insert_text (AtkEditableText *text,
const gchar *string,
- gint length,
- gint *position)
+ int length,
+ int *position)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_search_entry_accessible_copy_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_search_entry_accessible_cut_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_search_entry_accessible_delete_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_search_entry_accessible_paste_text (AtkEditableText *text,
- gint position)
+ int position)
{
GtkWidget *widget;
GtkEditable *editable;
static gboolean
gtk_search_entry_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
return FALSE;
}
-static gint
+static int
gtk_search_entry_accessible_get_n_actions (AtkAction *action)
{
GtkAccessible *accessible = GTK_ACCESSIBLE (action);
static const gchar *
gtk_search_entry_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkWidget *label;
static const gchar *
gtk_search_entry_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
switch (i)
{
static const gchar*
gtk_search_entry_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Activate");
static const gchar *
gtk_search_entry_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Activates the entry");
static void
gtk_spinner_accessible_image_get_size (AtkImage *image,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWidget *widget;
return gtk_statusbar_get_message (GTK_STATUSBAR (widget));
}
-static gint
+static int
gtk_statusbar_accessible_get_n_children (AtkObject *obj)
{
return 0;
static AtkObject*
gtk_statusbar_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
return NULL;
}
{
}
-static gint
+static int
gtk_switch_action_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_switch_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "toggle";
static const gchar *
gtk_switch_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Toggle");
static const gchar *
gtk_switch_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Toggles the switch");
static gboolean
gtk_switch_action_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkSwitch *sw;
GtkWidget *widget;
struct _GtkTextAccessiblePrivate
{
- gint cursor_position;
- gint selection_bound;
+ int cursor_position;
+ int selection_bound;
};
/* Callbacks */
static void insert_text_cb (GtkEditable *editable,
gchar *new_text,
- gint new_text_length,
- gint *position);
+ int new_text_length,
+ int *position);
static void delete_text_cb (GtkEditable *editable,
- gint start,
- gint end);
+ int start,
+ int end);
static gboolean check_for_selection_change (GtkTextAccessible *entry,
GtkText *gtk_text);
{
GtkText *entry;
GtkTextAccessible *gtk_text_accessible;
- gint start_pos, end_pos;
+ int start_pos, end_pos;
ATK_OBJECT_CLASS (gtk_text_accessible_parent_class)->initialize (obj, data);
obj->role = ATK_ROLE_PASSWORD_TEXT;
}
-static gint
+static int
gtk_text_accessible_get_index_in_parent (AtkObject *accessible)
{
/* If the parent widget is a combo box then the index is 1
static gchar *
gtk_text_accessible_get_text (AtkText *atk_text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
static gchar *
gtk_text_accessible_get_text_before_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
static gchar *
gtk_text_accessible_get_text_at_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
static gchar *
gtk_text_accessible_get_text_after_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
start_offset, end_offset);
}
-static gint
+static int
gtk_text_accessible_get_character_count (AtkText *atk_text)
{
GtkWidget *widget;
return char_count;
}
-static gint
+static int
gtk_text_accessible_get_caret_offset (AtkText *text)
{
GtkWidget *widget;
static gboolean
gtk_text_accessible_set_caret_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkWidget *widget;
static AtkAttributeSet *
add_text_attribute (AtkAttributeSet *attributes,
AtkTextAttribute attr,
- gint i)
+ int i)
{
AtkAttribute *at;
static AtkAttributeSet *
gtk_text_accessible_get_run_attributes (AtkText *text,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
AtkAttributeSet *attributes;
static void
gtk_text_accessible_get_character_extents (AtkText *text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords)
{
GtkWidget *widget;
GtkText *entry;
PangoRectangle char_rect;
gchar *entry_text;
- gint index, x_layout, y_layout;
+ int index, x_layout, y_layout;
GtkAllocation allocation;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
*height = char_rect.height;
}
-static gint
+static int
gtk_text_accessible_get_offset_at_point (AtkText *atk_text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
GtkWidget *widget;
GtkText *entry;
gchar *text;
- gint index, x_layout, y_layout;
- gint x_local, y_local;
+ int index, x_layout, y_layout;
+ int x_local, y_local;
glong offset;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (atk_text));
return offset;
}
-static gint
+static int
gtk_text_accessible_get_n_selections (AtkText *text)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gchar *
gtk_text_accessible_get_selection (AtkText *text,
- gint selection_num,
- gint *start_pos,
- gint *end_pos)
+ int selection_num,
+ int *start_pos,
+ int *end_pos)
{
GtkWidget *widget;
static gboolean
gtk_text_accessible_add_selection (AtkText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkText *entry;
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_text_accessible_remove_selection (AtkText *text,
- gint selection_num)
+ int selection_num)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gboolean
gtk_text_accessible_set_selection (AtkText *text,
- gint selection_num,
- gint start_pos,
- gint end_pos)
+ int selection_num,
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
- gint start, end;
+ int start, end;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
static gunichar
gtk_text_accessible_get_character_at_offset (AtkText *atk_text,
- gint offset)
+ int offset)
{
GtkWidget *widget;
gchar *text;
static void
gtk_text_accessible_insert_text (AtkEditableText *text,
const gchar *string,
- gint length,
- gint *position)
+ int length,
+ int *position)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_text_accessible_copy_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_text_accessible_cut_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
static void
gtk_text_accessible_delete_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkEditable *editable;
typedef struct
{
GtkText* entry;
- gint position;
+ int position;
} PasteData;
static void
static void
gtk_text_accessible_paste_text (AtkEditableText *text,
- gint position)
+ int position)
{
GtkWidget *widget;
GtkEditable *editable;
static void
insert_text_cb (GtkEditable *editable,
gchar *new_text,
- gint new_text_length,
- gint *position)
+ int new_text_length,
+ int *position)
{
GtkTextAccessible *accessible;
- gint length;
+ int length;
if (new_text_length == 0)
return;
*/
static void
delete_text_cb (GtkEditable *editable,
- gint start,
- gint end)
+ int start,
+ int end)
{
GtkTextAccessible *accessible;
GtkText *entry)
{
gboolean ret_val = FALSE;
- gint start, end;
+ int start, end;
if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
{
static gboolean
gtk_text_accessible_do_action (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_text_accessible_get_n_actions (AtkAction *action)
{
return 1;
static const gchar *
gtk_text_accessible_get_keybinding (AtkAction *action,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkWidget *label;
static const gchar*
gtk_text_accessible_action_get_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return "activate";
static const gchar*
gtk_text_accessible_action_get_localized_name (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action name", "Activate");
static const gchar*
gtk_text_accessible_action_get_description (AtkAction *action,
- gint i)
+ int i)
{
if (i == 0)
return C_("Action description", "Activates the entry");
struct _GtkTextCellAccessiblePrivate
{
gchar *cell_text;
- gint caret_pos;
- gint cell_length;
+ int caret_pos;
+ int cell_length;
PangoLayout *layout;
};
/* atktext.h */
static gchar* gtk_text_cell_accessible_get_text (AtkText *text,
- gint start_pos,
- gint end_pos);
+ int start_pos,
+ int end_pos);
static gunichar gtk_text_cell_accessible_get_character_at_offset (AtkText *text,
- gint offset);
+ int offset);
static gchar* gtk_text_cell_accessible_get_text_before_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset);
+ int *start_offset,
+ int *end_offset);
static gchar* gtk_text_cell_accessible_get_text_at_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset);
+ int *start_offset,
+ int *end_offset);
static gchar* gtk_text_cell_accessible_get_text_after_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset);
-static gint gtk_text_cell_accessible_get_character_count (AtkText *text);
-static gint gtk_text_cell_accessible_get_caret_offset (AtkText *text);
+ int *start_offset,
+ int *end_offset);
+static int gtk_text_cell_accessible_get_character_count (AtkText *text);
+static int gtk_text_cell_accessible_get_caret_offset (AtkText *text);
static gboolean gtk_text_cell_accessible_set_caret_offset (AtkText *text,
- gint offset);
+ int offset);
static void gtk_text_cell_accessible_get_character_extents (AtkText *text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords);
-static gint gtk_text_cell_accessible_get_offset_at_point (AtkText *text,
- gint x,
- gint y,
+static int gtk_text_cell_accessible_get_offset_at_point (AtkText *text,
+ int x,
+ int y,
AtkCoordType coords);
static AtkAttributeSet* gtk_text_cell_accessible_get_run_attributes
(AtkText *text,
- gint offset,
- gint *start_offset,
- gint *end_offset);
+ int offset,
+ int *start_offset,
+ int *end_offset);
static AtkAttributeSet* gtk_text_cell_accessible_get_default_attributes
(AtkText *text);
{
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (cell);
AtkObject *obj = ATK_OBJECT (cell);
- gint text_length;
+ int text_length;
gchar *text;
GtkCellRenderer *renderer;
static gchar *
gtk_text_cell_accessible_get_text (AtkText *atk_text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
gchar *text;
static gchar *
gtk_text_cell_accessible_get_text_before_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (atk_text);
gchar *text;
static gchar *
gtk_text_cell_accessible_get_text_at_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (atk_text);
gchar *text;
static gchar *
gtk_text_cell_accessible_get_text_after_offset (AtkText *atk_text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (atk_text);
gchar *text;
return text;
}
-static gint
+static int
gtk_text_cell_accessible_get_character_count (AtkText *text)
{
if (GTK_TEXT_CELL_ACCESSIBLE (text)->priv->cell_text != NULL)
return 0;
}
-static gint
+static int
gtk_text_cell_accessible_get_caret_offset (AtkText *text)
{
return GTK_TEXT_CELL_ACCESSIBLE (text)->priv->caret_pos;
static gboolean
gtk_text_cell_accessible_set_caret_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (text);
static AtkAttributeSet *
gtk_text_cell_accessible_get_run_attributes (AtkText *text,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
AtkAttributeSet *attrib_set = NULL;
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (text);
gboolean scale_set, underline_set, rise_set;
gchar *renderer_text;
gdouble scale;
- gint rise;
+ int rise;
GtkRendererCellAccessible *gail_renderer;
GtkCellRendererText *gtk_renderer;
static void
gtk_text_cell_accessible_get_character_extents (AtkText *text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords)
{
GtkRendererCellAccessible *gail_renderer;
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (text);
gchar *renderer_text;
gfloat xalign, yalign;
- gint x_offset, y_offset, index;
- gint xpad, ypad;
+ int x_offset, y_offset, index;
+ int xpad, ypad;
if (!GTK_TEXT_CELL_ACCESSIBLE (text)->priv->cell_text)
{
g_object_unref (gtk_renderer);
}
-static gint
+static int
gtk_text_cell_accessible_get_offset_at_point (AtkText *text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
AtkObject *parent;
GtkTextCellAccessible *text_cell = GTK_TEXT_CELL_ACCESSIBLE (text);
gchar *renderer_text;
gfloat xalign, yalign;
- gint x_offset, y_offset, index;
- gint xpad, ypad;
- gint x_temp, y_temp;
+ int x_offset, y_offset, index;
+ int xpad, ypad;
+ int x_temp, y_temp;
gboolean ret;
if (!GTK_TEXT_CELL_ACCESSIBLE (text)->priv->cell_text)
static gunichar
gtk_text_cell_accessible_get_character_at_offset (AtkText *text,
- gint offset)
+ int offset)
{
gchar *index;
gchar *string;
struct _GtkTextViewAccessiblePrivate
{
- gint insert_offset;
- gint selection_bound;
+ int insert_offset;
+ int selection_bound;
};
static void insert_text_cb (GtkTextBuffer *buffer,
GtkTextIter *arg1,
gchar *arg2,
- gint arg3,
+ int arg3,
gpointer user_data);
static void delete_range_cb (GtkTextBuffer *buffer,
GtkTextIter *arg1,
static gchar *
gtk_text_view_accessible_get_text (AtkText *text,
- gint start_offset,
- gint end_offset)
+ int start_offset,
+ int end_offset)
{
GtkTextView *view;
GtkTextBuffer *buffer;
static gchar *
gtk_text_view_accessible_get_text_after_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
GtkTextView *view;
static gchar *
gtk_text_view_accessible_get_text_at_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
GtkTextView *view;
static gchar *
gtk_text_view_accessible_get_text_before_offset (AtkText *text,
- gint offset,
+ int offset,
AtkTextBoundary boundary_type,
- gint *start_offset,
- gint *end_offset)
+ int *start_offset,
+ int *end_offset)
{
GtkWidget *widget;
GtkTextView *view;
static gunichar
gtk_text_view_accessible_get_character_at_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkWidget *widget;
GtkTextIter start, end;
return unichar;
}
-static gint
+static int
gtk_text_view_accessible_get_character_count (AtkText *text)
{
GtkWidget *widget;
return gtk_text_buffer_get_char_count (buffer);
}
-static gint
+static int
get_insert_offset (GtkTextBuffer *buffer)
{
GtkTextMark *insert;
return gtk_text_iter_get_offset (&iter);
}
-static gint
+static int
gtk_text_view_accessible_get_caret_offset (AtkText *text)
{
GtkWidget *widget;
static gboolean
gtk_text_view_accessible_set_caret_offset (AtkText *text,
- gint offset)
+ int offset)
{
GtkTextView *view;
GtkWidget *widget;
return TRUE;
}
-static gint
+static int
gtk_text_view_accessible_get_offset_at_point (AtkText *text,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coords)
{
GtkTextView *view;
GtkTextIter iter;
- gint buff_x, buff_y;
+ int buff_x, buff_y;
GtkWidget *widget;
GdkRectangle rect;
static void
gtk_text_view_accessible_get_character_extents (AtkText *text,
- gint offset,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int offset,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coords)
{
GtkTextView *view;
static AtkAttributeSet *
add_text_int_attribute (AtkAttributeSet *attributes,
AtkTextAttribute attr,
- gint i)
+ int i)
{
gchar *value;
static AtkAttributeSet *
gtk_text_view_accessible_get_run_attributes (AtkText *text,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
GtkTextView *view;
GtkTextBuffer *buffer;
if (val_set)
{
- gint weight;
+ int weight;
gchar *value;
g_object_get (tag, "weight", &weight, NULL);
value = g_strdup_printf ("%d", weight);
g_object_get (tag, "size-set", &val_set, NULL);
if (val_set)
{
- gint size;
+ int size;
gchar *value;
g_object_get (tag, "size", &size, NULL);
value = g_strdup_printf ("%i", size);
g_object_get (tag, "rise-set", &val_set, NULL);
if (val_set)
{
- gint rise;
+ int rise;
gchar *value;
g_object_get (tag, "rise", &rise, NULL);
value = g_strdup_printf ("%i", rise);
g_object_get (tag, "pixels-inside-wrap-set", &val_set, NULL);
if (val_set)
{
- gint pixels;
+ int pixels;
gchar *value;
g_object_get (tag, "pixels-inside-wrap", &pixels, NULL);
value = g_strdup_printf ("%i", pixels);
g_object_get (tag, "pixels-below-lines-set", &val_set, NULL);
if (val_set)
{
- gint pixels;
+ int pixels;
gchar *value;
g_object_get (tag, "pixels-below-lines", &pixels, NULL);
value = g_strdup_printf ("%i", pixels);
g_object_get (tag, "pixels-above-lines-set", &val_set, NULL);
if (val_set)
{
- gint pixels;
+ int pixels;
gchar *value;
g_object_get (tag, "pixels-above-lines", &pixels, NULL);
value = g_strdup_printf ("%i", pixels);
g_object_get (tag, "indent-set", &val_set, NULL);
if (val_set)
{
- gint indent;
+ int indent;
gchar *value;
g_object_get (tag, "indent", &indent, NULL);
value = g_strdup_printf ("%i", indent);
g_object_get (tag, "right-margin-set", &val_set, NULL);
if (val_set)
{
- gint margin;
+ int margin;
gchar *value;
g_object_get (tag, "right-margin", &margin, NULL);
value = g_strdup_printf ("%i", margin);
g_object_get (tag, "left-margin-set", &val_set, NULL);
if (val_set)
{
- gint margin;
+ int margin;
gchar *value;
g_object_get (tag, "left-margin", &margin, NULL);
value = g_strdup_printf ("%i", margin);
return attributes;
}
-static gint
+static int
gtk_text_view_accessible_get_n_selections (AtkText *text)
{
GtkWidget *widget;
static gchar *
gtk_text_view_accessible_get_selection (AtkText *atk_text,
- gint selection_num,
- gint *start_pos,
- gint *end_pos)
+ int selection_num,
+ int *start_pos,
+ int *end_pos)
{
GtkTextView *view;
GtkWidget *widget;
static gboolean
gtk_text_view_accessible_add_selection (AtkText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
static gboolean
gtk_text_view_accessible_remove_selection (AtkText *text,
- gint selection_num)
+ int selection_num)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
static gboolean
gtk_text_view_accessible_set_selection (AtkText *text,
- gint selection_num,
- gint start_pos,
- gint end_pos)
+ int selection_num,
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
static gboolean
gtk_text_view_accessible_set_run_attributes (AtkEditableText *text,
AtkAttributeSet *attributes,
- gint start_offset,
- gint end_offset)
+ int start_offset,
+ int end_offset)
{
GtkTextView *view;
GtkTextBuffer *buffer;
GtkTextTag *tag;
GtkTextIter start;
GtkTextIter end;
- gint j;
+ int j;
GdkRGBA *color;
gchar** RGB_vals;
GSList *l;
static void
gtk_text_view_accessible_insert_text (AtkEditableText *text,
const gchar *string,
- gint length,
- gint *position)
+ int length,
+ int *position)
{
GtkTextView *view;
GtkWidget *widget;
static void
gtk_text_view_accessible_copy_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
static void
gtk_text_view_accessible_cut_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkTextView *view;
GtkWidget *widget;
static void
gtk_text_view_accessible_delete_text (AtkEditableText *text,
- gint start_pos,
- gint end_pos)
+ int start_pos,
+ int end_pos)
{
GtkTextView *view;
GtkWidget *widget;
typedef struct
{
GtkTextBuffer* buffer;
- gint position;
+ int position;
} PasteData;
static void
static void
gtk_text_view_accessible_paste_text (AtkEditableText *text,
- gint position)
+ int position)
{
GtkTextView *view;
GtkWidget *widget;
insert_text_cb (GtkTextBuffer *buffer,
GtkTextIter *iter,
gchar *text,
- gint len,
+ int len,
gpointer data)
{
GtkTextViewAccessible *accessible = data;
- gint position;
- gint length;
+ int position;
+ int length;
position = gtk_text_iter_get_offset (iter);
length = g_utf8_strlen (text, len);
gpointer data)
{
GtkTextViewAccessible *accessible = data;
- gint offset, length;
+ int offset, length;
offset = gtk_text_iter_get_offset (start);
length = gtk_text_iter_get_offset (end) - offset;
G_OBJECT_CLASS (gtk_toplevel_accessible_parent_class)->finalize (obj);
}
-static gint
+static int
gtk_toplevel_accessible_get_n_children (AtkObject *obj)
{
GtkToplevelAccessible *toplevel = GTK_TOPLEVEL_ACCESSIBLE (obj);
static AtkObject *
gtk_toplevel_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
GtkToplevelAccessible *toplevel;
GtkWidget *widget;
AtkObject *atk_obj = ATK_OBJECT (toplevel);
GObject *object;
GtkWidget *widget;
- gint n_children;
+ int n_children;
AtkObject *child;
object = g_value_get_object (param_values + 0);
GtkTreeRBNode *node,
GtkTreeViewColumn *tv_col,
GtkCellAccessible *cell);
-static gint get_column_number (GtkTreeView *tree_view,
+static int get_column_number (GtkTreeView *tree_view,
GtkTreeViewColumn *column);
static gboolean get_rbtree_column_from_index (GtkTreeView *tree_view,
- gint index,
+ int index,
GtkTreeRBTree **tree,
GtkTreeRBNode **node,
GtkTreeViewColumn **column);
GTK_ACCESSIBLE_CLASS (gtk_tree_view_accessible_parent_class)->widget_unset (gtkaccessible);
}
-static gint
+static int
get_n_rows (GtkTreeView *tree_view)
{
GtkTreeRBTree *tree;
return tree->root->total_count;
}
-static gint
+static int
get_n_columns (GtkTreeView *tree_view)
{
guint i, visible_columns;
return visible_columns;
}
-static gint
+static int
gtk_tree_view_accessible_get_n_children (AtkObject *obj)
{
GtkWidget *widget;
static AtkObject *
gtk_tree_view_accessible_ref_child (AtkObject *obj,
- gint i)
+ int i)
{
GtkWidget *widget;
GtkTreeViewAccessible *accessible;
static AtkObject *
gtk_tree_view_accessible_ref_accessible_at_point (AtkComponent *component,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coord_type)
{
GtkWidget *widget;
GtkTreeView *tree_view;
GtkTreePath *path;
GtkTreeViewColumn *column;
- gint x_pos, y_pos;
- gint bx, by;
+ int x_pos, y_pos;
+ int bx, by;
GtkCellAccessible *cell;
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
/* atktable.h */
-static gint
+static int
gtk_tree_view_accessible_get_index_at (AtkTable *table,
- gint row,
- gint column)
+ int row,
+ int column)
{
GtkWidget *widget;
- gint n_cols, n_rows;
+ int n_cols, n_rows;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
if (widget == NULL)
return (row + 1) * n_cols + column;
}
-static gint
+static int
gtk_tree_view_accessible_get_column_at_index (AtkTable *table,
- gint index)
+ int index)
{
GtkWidget *widget;
- gint n_columns;
+ int n_columns;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
if (widget == NULL)
return index % n_columns;
}
-static gint
+static int
gtk_tree_view_accessible_get_row_at_index (AtkTable *table,
- gint index)
+ int index)
{
GtkWidget *widget;
GtkTreeView *tree_view;
static AtkObject *
gtk_tree_view_accessible_table_ref_at (AtkTable *table,
- gint row,
- gint column)
+ int row,
+ int column)
{
- gint index;
+ int index;
index = gtk_tree_view_accessible_get_index_at (table, row, column);
if (index == -1)
return gtk_tree_view_accessible_ref_child (ATK_OBJECT (table), index);
}
-static gint
+static int
gtk_tree_view_accessible_get_n_rows (AtkTable *table)
{
GtkWidget *widget;
return get_n_rows (GTK_TREE_VIEW (widget));
}
-static gint
+static int
gtk_tree_view_accessible_get_n_columns (AtkTable *table)
{
GtkWidget *widget;
static gboolean
gtk_tree_view_accessible_is_row_selected (AtkTable *table,
- gint row)
+ int row)
{
GtkWidget *widget;
GtkTreeRBTree *tree;
static gboolean
gtk_tree_view_accessible_is_selected (AtkTable *table,
- gint row,
- gint column)
+ int row,
+ int column)
{
return gtk_tree_view_accessible_is_row_selected (table, row);
}
g_array_append_val (data->array, id);
}
-static gint
+static int
gtk_tree_view_accessible_get_selected_rows (AtkTable *table,
- gint **rows_selected)
+ int **rows_selected)
{
SelectedRowsData data;
GtkWidget *widget;
- gint n_rows;
+ int n_rows;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (table));
if (widget == NULL)
}
data.treeview = GTK_TREE_VIEW (widget);
- data.array = g_array_new (FALSE, FALSE, sizeof (gint));
+ data.array = g_array_new (FALSE, FALSE, sizeof (int));
gtk_tree_selection_selected_foreach (gtk_tree_view_get_selection (data.treeview),
get_selected_rows,
n_rows = data.array->len;
if (rows_selected)
- *rows_selected = (gint *) g_array_free (data.array, FALSE);
+ *rows_selected = (int *) g_array_free (data.array, FALSE);
else
g_array_free (data.array, TRUE);
static gboolean
gtk_tree_view_accessible_add_row_selection (AtkTable *table,
- gint row)
+ int row)
{
GtkTreeView *treeview;
GtkTreePath *path;
static gboolean
gtk_tree_view_accessible_remove_row_selection (AtkTable *table,
- gint row)
+ int row)
{
GtkTreeView *treeview;
GtkTreePath *path;
static AtkObject *
gtk_tree_view_accessible_get_column_header (AtkTable *table,
- gint in_col)
+ int in_col)
{
GtkWidget *widget;
GtkTreeView *tree_view;
static const gchar *
gtk_tree_view_accessible_get_column_description (AtkTable *table,
- gint in_col)
+ int in_col)
{
GtkWidget *widget;
GtkTreeView *tree_view;
static gboolean
gtk_tree_view_accessible_add_selection (AtkSelection *selection,
- gint i)
+ int i)
{
AtkTable *table;
- gint n_columns;
- gint row;
+ int n_columns;
+ int row;
table = ATK_TABLE (selection);
n_columns = gtk_tree_view_accessible_get_n_columns (table);
static AtkObject *
gtk_tree_view_accessible_ref_selection (AtkSelection *selection,
- gint i)
+ int i)
{
AtkTable *table;
- gint row;
- gint n_selected;
- gint n_columns;
- gint *selected;
+ int row;
+ int n_selected;
+ int n_columns;
+ int *selected;
table = ATK_TABLE (selection);
n_columns = gtk_tree_view_accessible_get_n_columns (table);
return gtk_tree_view_accessible_table_ref_at (table, row, i % n_columns);
}
-static gint
+static int
gtk_tree_view_accessible_get_selection_count (AtkSelection *selection)
{
AtkTable *table;
- gint n_selected;
+ int n_selected;
table = ATK_TABLE (selection);
n_selected = gtk_tree_view_accessible_get_selected_rows (table, NULL);
static gboolean
gtk_tree_view_accessible_is_child_selected (AtkSelection *selection,
- gint i)
+ int i)
{
GtkWidget *widget;
- gint row;
+ int row;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (selection));
if (widget == NULL)
/* Values from gtktreeview.c ... */
#define _TREE_VIEW_EXPANDER_SIZE 16
#define _TREE_VIEW_HORIZONTAL_SEPARATOR 4
- gint expander_size = _TREE_VIEW_EXPANDER_SIZE + (_TREE_VIEW_HORIZONTAL_SEPARATOR / 2);
+ int expander_size = _TREE_VIEW_EXPANDER_SIZE + (_TREE_VIEW_HORIZONTAL_SEPARATOR / 2);
cell_rect->x += expander_size + EXTRA_EXPANDER_PADDING;
cell_rect->width -= expander_size + EXTRA_EXPANDER_PADDING;
}
*/
if (top_cell != cell)
{
- gint cell_index;
+ int cell_index;
gboolean found;
- gint cell_start;
- gint cell_width;
+ int cell_start;
+ int cell_width;
GList *renderers;
GtkCellRenderer *renderer;
static void
gtk_tree_view_accessible_get_cell_extents (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkWidget *widget;
GtkTreeView *tree_view;
GdkRectangle cell_rect;
- gint w_x, w_y;
+ int w_x, w_y;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
if (widget == NULL)
GtkTreeViewAccessibleCellInfo *cell_info;
GtkCellRenderer *renderer = NULL;
GtkWidget *toplevel;
- gint index;
+ int index;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (parent));
if (widget == NULL)
static void
gtk_tree_view_accessible_get_cell_position (GtkCellAccessibleParent *parent,
GtkCellAccessible *cell,
- gint *row,
- gint *column)
+ int *row,
+ int *column)
{
GtkWidget *widget;
GtkTreeView *tree_view;
{
GdkRectangle rect, *visible_rect;
GdkRectangle rect1, *tree_cell_rect;
- gint bx, by;
+ int bx, by;
gboolean is_showing;
/* A cell is considered "SHOWING" if any part of the cell is
/* Returns the column number of the specified GtkTreeViewColumn
* The column must be visible.
*/
-static gint
+static int
get_column_number (GtkTreeView *treeview,
GtkTreeViewColumn *column)
{
static gboolean
get_rbtree_column_from_index (GtkTreeView *tree_view,
- gint index,
+ int index,
GtkTreeRBTree **tree,
GtkTreeRBNode **node,
GtkTreeViewColumn **column)
*/
if (GTK_IS_NOTEBOOK (parent_widget))
{
- gint page_num;
+ int page_num;
GtkWidget *child;
GtkNotebook *notebook;
return state_set;
}
-static gint
+static int
gtk_widget_accessible_get_index_in_parent (AtkObject *accessible)
{
GtkWidget *widget;
GtkWidget *parent_widget;
- gint index;
+ int index;
GtkWidget *ch;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
return 0;
else
{
- gint n_children, i;
+ int n_children, i;
gboolean found = FALSE;
n_children = atk_object_get_n_accessible_children (parent);
static void
gtk_widget_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkWidget *widget;
static gboolean
gtk_widget_accessible_set_extents (AtkComponent *component,
- gint x,
- gint y,
- gint width,
- gint height,
+ int x,
+ int y,
+ int width,
+ int height,
AtkCoordType coord_type)
{
return FALSE;
static gboolean
gtk_widget_accessible_set_position (AtkComponent *component,
- gint x,
- gint y,
+ int x,
+ int y,
AtkCoordType coord_type)
{
return FALSE;
static gboolean
gtk_widget_accessible_set_size (AtkComponent *component,
- gint width,
- gint height)
+ int width,
+ int height)
{
return FALSE;
}
/* atkcomponent.h */
static void gtk_window_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type);
static void gtk_window_accessible_get_size (AtkComponent *component,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
static void atk_component_interface_init (AtkComponentIface *iface);
static void atk_window_interface_init (AtkWindowIface *iface);
return name;
}
-static gint
+static int
gtk_window_accessible_get_index_in_parent (AtkObject *accessible)
{
GtkWidget* widget;
AtkObject* atk_obj;
- gint index = -1;
+ int index = -1;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
if (widget == NULL)
}
else
{
- gint i, sibling_count;
+ int i, sibling_count;
sibling_count = atk_object_get_n_accessible_children (atk_obj);
for (i = 0; i < sibling_count && index == -1; ++i)
return state_set;
}
-static gint
+static int
gtk_window_accessible_get_n_children (AtkObject *object)
{
GtkWidget *window;
GtkWidget *child;
- gint count = 0;
+ int count = 0;
window = gtk_accessible_get_widget (GTK_ACCESSIBLE (object));
for (child = gtk_widget_get_first_child (GTK_WIDGET (window));
static AtkObject *
gtk_window_accessible_ref_child (AtkObject *object,
- gint i)
+ int i)
{
GtkWidget *window, *child;
int pos;
static void
gtk_window_accessible_get_extents (AtkComponent *component,
- gint *x,
- gint *y,
- gint *width,
- gint *height,
+ int *x,
+ int *y,
+ int *width,
+ int *height,
AtkCoordType coord_type)
{
GtkWidget *widget;
static void
gtk_window_accessible_get_size (AtkComponent *component,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWidget *widget;
GdkSurface *surface;
struct _GtkCssSection
{
- gint ref_count;
+ int ref_count;
GtkCssSection *parent;
GFile *file;
GtkCssLocation start_location;
struct _GtkCssTokenizer
{
- gint ref_count;
+ int ref_count;
GBytes *bytes;
const gchar *data;
#include "paper_names.c"
-static const gint n_infos = G_N_ELEMENTS (standard_names);
-static const gint n_extra = G_N_ELEMENTS (extra_ppd_names);
+static const int n_infos = G_N_ELEMENTS (standard_names);
+static const int n_extra = G_N_ELEMENTS (extra_ppd_names);
typedef struct {
const gchar *s;
- gint len;
- gint suffix;
- gint offset;
+ int len;
+ int suffix;
+ int offset;
} NameInfo;
static NameInfo *names = NULL;
-static gint n_names = 0;
+static int n_names = 0;
static void
add_name (const gchar *name)
n_names++;
}
-static gint
+static int
find_name (const gchar *name)
{
- gint i;
+ int i;
if (!name)
return -1;
int
main (int argc, char *argv[])
{
- gint i, j, offset;
+ int i, j, offset;
gdouble width, height;
names = (NameInfo *) malloc (sizeof (NameInfo) * (4 + n_infos + 2 * n_extra));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (G_MININT32 <= l && l <= G_MAXINT32)
- variant = g_variant_new_int32 ((gint) l);
+ variant = g_variant_new_int32 ((int) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (G_MININT32 <= l && l <= G_MAXINT32)
- variant = g_variant_new_int32 ((gint) l);
+ variant = g_variant_new_int32 ((int) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (u <= G_MAXINT32)
- variant = g_variant_new_int32 ((gint) u);
+ variant = g_variant_new_int32 ((int) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
GtkTextIter *iter);
static void set_cursor_if_appropriate (GtkAboutDialog *about,
GtkTextView *text_view,
- gint x,
- gint y);
+ int x,
+ int y);
static void populate_credits_page (GtkAboutDialog *about);
static void populate_license_page (GtkAboutDialog *about);
static void populate_system_page (GtkAboutDialog *about);
if (icon_name)
{
GtkIconTheme *icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (GTK_WIDGET (about)));
- gint *sizes = gtk_icon_theme_get_icon_sizes (icon_theme, icon_name);
- gint i, best_size = 0;
+ int *sizes = gtk_icon_theme_get_icon_sizes (icon_theme, icon_name);
+ int i, best_size = 0;
for (i = 0; sizes[i]; i++)
{
GtkWidget *text_view;
GtkTextIter start, end, iter;
GtkTextBuffer *buffer;
- gint tx, ty;
+ int tx, ty;
if (gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)) != GDK_BUTTON_PRIMARY)
return;
static void
set_cursor_if_appropriate (GtkAboutDialog *about,
GtkTextView *text_view,
- gint x,
- gint y)
+ int x,
+ int y)
{
GSList *tags = NULL, *tagp = NULL;
GtkTextIter iter;
double y,
GtkAboutDialog *about)
{
- gint tx, ty;
+ int tx, ty;
GtkWidget *widget;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (motion));
static void
add_credits_section (GtkAboutDialog *about,
GtkGrid *grid,
- gint *row,
+ int *row,
gchar *title,
gchar **people)
{
static void
populate_credits_page (GtkAboutDialog *about)
{
- gint row;
+ int row;
row = 0;
{
guint keyval;
GdkModifierType mods;
- gint len;
+ int len;
gboolean error;
if (accelerator_key)
{
char keystring[5];
gchar *endptr;
- gint tmp_keycode;
+ int tmp_keycode;
memcpy (keystring, accelerator, 4);
keystring [4] = '\000';
if (keyval && accelerator_codes != NULL)
{
GdkKeymapKey *keys;
- gint n_keys, i, j;
+ int n_keys, i, j;
if (!gdk_display_map_keyval (display, keyval, &keys, &n_keys))
{
GtkButtonRole role;
- gint reporting;
+ int reporting;
};
enum
gtk_action_muxer_free_group (gpointer data)
{
Group *group = data;
- gint i;
+ int i;
/* 'for loop' or 'four loop'? */
for (i = 0; i < 4; i++)
{
gchar **actions;
Group *group;
- gint i;
+ int i;
/* TODO: diff instead of ripout and replace */
gtk_action_muxer_remove (muxer, prefix);
if (group != NULL)
{
gchar **actions;
- gint i;
+ int i;
g_hash_table_steal (muxer->groups, prefix);
GParamSpec **pspecs)
{
gboolean changed = FALSE;
- gint i;
+ int i;
G_OBJECT_CLASS (gtk_adjustment_parent_class)->dispatch_properties_changed (object, n_pspecs, pspecs);
gchar *content_type;
gchar *heading;
- gint last_active;
+ int last_active;
gboolean show_dialog_item;
gboolean show_default_item;
gboolean modal;
typedef struct {
GtkAppChooserButton *self;
GAppInfo *info;
- gint active_index;
+ int active_index;
} SelectAppData;
static void
static void
other_application_dialog_response_cb (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GtkAppChooserButton *self = user_data;
static void
gtk_app_chooser_dialog_response (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GtkAppChooserDialog *self = GTK_APP_CHOOSER_DIALOG (dialog);
static gboolean
gtk_app_chooser_search_equal_func (GtkTreeModel *model,
- gint column,
+ int column,
const gchar *key,
GtkTreeIter *iter,
gpointer user_data)
}
}
-static gint
+static int
gtk_app_chooser_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gboolean a_heading, b_heading;
gboolean a_default, b_default;
gchar *a_name, *b_name, *a_casefold, *b_casefold;
- gint retval = 0;
+ int retval = 0;
/* this returns:
* - <0 if a should show before b
return !heading;
}
-static gint
+static int
compare_apps_func (gconstpointer a,
gconstpointer b)
{
guint *id,
gchar **path)
{
- gint i;
+ int i;
if (dbus->session == NULL)
return;
GNSMenuItem *item = user_data;
GError *error = NULL;
GdkPixbuf *pixbuf;
- gint scale = 1;
+ int scale = 1;
#ifdef AVAILABLE_MAC_OS_X_VERSION_10_7_AND_LATER
/* we need a run-time check for the backingScaleFactor selector because we
GtkIconTheme *theme;
GtkIconPaintable *icon;
- gint scale = 1;
+ int scale = 1;
if (!parsed)
{
static void
menu_item_inserted (GtkMenuTrackerItem *item,
- gint position,
+ int position,
gpointer user_data)
{
GNSMenu *menu = user_data;
}
static void
-menu_item_removed (gint position,
+menu_item_removed (int position,
gpointer user_data)
{
GNSMenu *menu = user_data;
GMenu *combined;
GSList *inhibitors;
- gint quit_inhibit;
+ int quit_inhibit;
guint next_cookie;
NSObject *delegate;
} GtkApplicationImplQuartz;
-(void)application:(NSApplication *)theApplication openFiles:(NSArray *)filenames
{
GFile **files;
- gint i;
+ int i;
GApplicationFlags flags;
flags = g_application_get_flags (G_APPLICATION (quartz->impl.application));
static gboolean
gtk_application_local_command_line (GApplication *application,
gchar ***arguments,
- gint *exit_status)
+ int *exit_status)
{
return G_APPLICATION_CLASS (gtk_application_parent_class)->local_command_line (application, arguments, exit_status);
}
{
GtkAllocation menubar_allocation;
GtkAllocation child_allocation;
- gint menubar_height;
+ int menubar_height;
GtkWidget *child;
_gtk_window_set_allocation (GTK_WINDOW (widget), width, height, &child_allocation);
GtkWidget *content;
GtkWidget *action_area;
GtkWidget *headerbar;
- gint use_header_bar;
+ int use_header_bar;
gboolean constructed;
GList *pages;
GListModel *model;
- gint extra_buttons;
+ int extra_buttons;
guint committed : 1;
};
static int gtk_assistant_add_page (GtkAssistant *assistant,
GtkAssistantPage *page_info,
- gint position);
+ int position);
GType _gtk_assistant_accessible_get_type (void);
static void
set_use_header_bar (GtkAssistant *assistant,
- gint use_header_bar)
+ int use_header_bar)
{
if (use_header_bar == -1)
return;
gtk_widget_class_bind_template_callback (widget_class, on_assistant_last);
}
-static gint
-default_forward_function (gint current_page, gpointer data)
+static int
+default_forward_function (int current_page, gpointer data)
{
GtkAssistant *assistant = GTK_ASSISTANT (data);
GtkAssistantPage *page_info;
last_button_visible (GtkAssistant *assistant, GtkAssistantPage *page)
{
GtkAssistantPage *page_info;
- gint count, page_num, n_pages;
+ int count, page_num, n_pages;
if (page == NULL)
return FALSE;
{
GList *l;
GtkAssistantPage *page;
- gint buttons, page_buttons;
+ int buttons, page_buttons;
if (!assistant->current_page)
return;
static void
compute_progress_state (GtkAssistant *assistant)
{
- gint page_num, n_pages;
+ int page_num, n_pages;
n_pages = gtk_assistant_get_n_pages (assistant);
page_num = gtk_assistant_get_current_page (assistant);
static void
set_current_page (GtkAssistant *assistant,
- gint page_num)
+ int page_num)
{
assistant->current_page = (GtkAssistantPage *)g_list_nth_data (assistant->pages, page_num);
if (!gtk_widget_child_focus (assistant->current_page->page, GTK_DIR_TAB_FORWARD))
{
GtkWidget *button[6];
- gint i;
+ int i;
/* find the best button to focus */
button[0] = assistant->apply;
}
}
-static gint
+static int
compute_next_step (GtkAssistant *assistant)
{
GtkAssistantPage *page_info;
- gint current_page, n_pages, next_page;
+ int current_page, n_pages, next_page;
current_page = gtk_assistant_get_current_page (assistant);
page_info = assistant->current_page;
GtkAssistant *assistant = GTK_ASSISTANT (widget);
GList *page_node;
GtkAssistantPage *page;
- gint page_num;
+ int page_num;
/* if there's no default page, pick the first one */
page = NULL;
* page in the @assistant, or -1 if the @assistant has no pages,
* or no current page.
*/
-gint
+int
gtk_assistant_get_current_page (GtkAssistant *assistant)
{
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), -1);
*/
void
gtk_assistant_set_current_page (GtkAssistant *assistant,
- gint page_num)
+ int page_num)
{
GtkAssistantPage *page;
*
* Returns: the number of pages in the @assistant
*/
-gint
+int
gtk_assistant_get_n_pages (GtkAssistant *assistant)
{
g_return_val_if_fail (GTK_IS_ASSISTANT (assistant), 0);
*/
GtkWidget*
gtk_assistant_get_nth_page (GtkAssistant *assistant,
- gint page_num)
+ int page_num)
{
GtkAssistantPage *page;
GList *elem;
*
* Returns: the index (starting at 0) of the inserted page
*/
-gint
+int
gtk_assistant_prepend_page (GtkAssistant *assistant,
GtkWidget *page)
{
*
* Returns: the index (starting at 0) of the inserted page
*/
-gint
+int
gtk_assistant_append_page (GtkAssistant *assistant,
GtkWidget *page)
{
*
* Returns: the index (starting from 0) of the inserted page
*/
-gint
+int
gtk_assistant_insert_page (GtkAssistant *assistant,
GtkWidget *page,
- gint position)
+ int position)
{
GtkAssistantPage *page_info;
static int
gtk_assistant_add_page (GtkAssistant *assistant,
GtkAssistantPage *page_info,
- gint position)
+ int position)
{
- gint n_pages;
+ int n_pages;
GtkWidget *sibling;
char *name;
*/
void
gtk_assistant_remove_page (GtkAssistant *assistant,
- gint page_num)
+ int page_num)
{
GtkWidget *page;
G_DEFINE_TYPE (GtkAssistantAccessible, _gtk_assistant_accessible, GTK_TYPE_WINDOW_ACCESSIBLE);
-static gint
+static int
gtk_assistant_accessible_get_n_children (AtkObject *accessible)
{
GtkWidget *widget;
static AtkObject *
gtk_assistant_accessible_ref_child (AtkObject *accessible,
- gint index)
+ int index)
{
GtkAssistant *assistant;
GtkWidget *widget, *child;
- gint n_pages;
+ int n_pages;
AtkObject *obj;
const gchar *title;
*
* Returns: The next page number.
*/
-typedef gint (*GtkAssistantPageFunc) (gint current_page, gpointer data);
+typedef int (*GtkAssistantPageFunc) (int current_page, gpointer data);
GDK_AVAILABLE_IN_ALL
GType gtk_assistant_page_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
void gtk_assistant_previous_page (GtkAssistant *assistant);
GDK_AVAILABLE_IN_ALL
-gint gtk_assistant_get_current_page (GtkAssistant *assistant);
+int gtk_assistant_get_current_page (GtkAssistant *assistant);
GDK_AVAILABLE_IN_ALL
void gtk_assistant_set_current_page (GtkAssistant *assistant,
- gint page_num);
+ int page_num);
GDK_AVAILABLE_IN_ALL
-gint gtk_assistant_get_n_pages (GtkAssistant *assistant);
+int gtk_assistant_get_n_pages (GtkAssistant *assistant);
GDK_AVAILABLE_IN_ALL
GtkWidget *gtk_assistant_get_nth_page (GtkAssistant *assistant,
- gint page_num);
+ int page_num);
GDK_AVAILABLE_IN_ALL
-gint gtk_assistant_prepend_page (GtkAssistant *assistant,
+int gtk_assistant_prepend_page (GtkAssistant *assistant,
GtkWidget *page);
GDK_AVAILABLE_IN_ALL
-gint gtk_assistant_append_page (GtkAssistant *assistant,
+int gtk_assistant_append_page (GtkAssistant *assistant,
GtkWidget *page);
GDK_AVAILABLE_IN_ALL
-gint gtk_assistant_insert_page (GtkAssistant *assistant,
+int gtk_assistant_insert_page (GtkAssistant *assistant,
GtkWidget *page,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_assistant_remove_page (GtkAssistant *assistant,
- gint page_num);
+ int page_num);
GDK_AVAILABLE_IN_ALL
void gtk_assistant_set_forward_page_func (GtkAssistant *assistant,
GtkAssistantPageFunc page_func,
{
gchar **lines, *space;
GSList *bookmarks = NULL;
- gint i;
+ int i;
lines = g_strsplit (contents, "\n", -1);
gboolean
_gtk_bookmarks_manager_insert_bookmark (GtkBookmarksManager *manager,
GFile *file,
- gint position,
+ int position,
GError **error)
{
GSList *link;
gboolean
_gtk_bookmarks_manager_reorder_bookmark (GtkBookmarksManager *manager,
GFile *file,
- gint new_position,
+ int new_position,
GError **error)
{
GSList *link;
gboolean _gtk_bookmarks_manager_insert_bookmark (GtkBookmarksManager *manager,
GFile *file,
- gint position,
+ int position,
GError **error);
gboolean _gtk_bookmarks_manager_remove_bookmark (GtkBookmarksManager *manager,
gboolean _gtk_bookmarks_manager_reorder_bookmark (GtkBookmarksManager *manager,
GFile *file,
- gint new_position,
+ int new_position,
GError **error);
gboolean _gtk_bookmarks_manager_has_bookmark (GtkBookmarksManager *manager,
**/
GtkWidget*
gtk_box_new (GtkOrientation orientation,
- gint spacing)
+ int spacing)
{
return g_object_new (GTK_TYPE_BOX,
"orientation", orientation,
*/
void
gtk_box_set_spacing (GtkBox *box,
- gint spacing)
+ int spacing)
{
GtkBoxLayout *box_layout;
*
* Returns: spacing between children
**/
-gint
+int
gtk_box_get_spacing (GtkBox *box)
{
GtkLayoutManager *box_layout;
GType gtk_box_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
GtkWidget* gtk_box_new (GtkOrientation orientation,
- gint spacing);
+ int spacing);
GDK_AVAILABLE_IN_ALL
void gtk_box_set_homogeneous (GtkBox *box,
gboolean homogeneous);
gboolean gtk_box_get_homogeneous (GtkBox *box);
GDK_AVAILABLE_IN_ALL
void gtk_box_set_spacing (GtkBox *box,
- gint spacing);
+ int spacing);
GDK_AVAILABLE_IN_ALL
-gint gtk_box_get_spacing (GtkBox *box);
+int gtk_box_get_spacing (GtkBox *box);
GDK_AVAILABLE_IN_ALL
void gtk_box_set_baseline_position (GtkBox *box,
GtkBaselinePosition position);
static void
count_expand_children (GtkWidget *widget,
GtkOrientation orientation,
- gint *visible_children,
- gint *expand_children)
+ int *visible_children,
+ int *expand_children)
{
GtkWidget *child;
}
}
-static gint
+static int
get_spacing (GtkBoxLayout *self,
GtkCssNode *node)
{
GtkCssStyle *style = gtk_css_node_get_style (node);
GtkCssValue *border_spacing;
- gint css_spacing;
+ int css_spacing;
border_spacing = style->size->border_spacing;
if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
{
GtkBoxLayout *self = GTK_BOX_LAYOUT (layout_manager);
GtkWidget *child;
- gint nvis_children;
- gint nexpand_children;
+ int nvis_children;
+ int nexpand_children;
GtkTextDirection direction;
GtkAllocation child_allocation;
GtkRequestedSize *sizes;
- gint child_minimum_baseline, child_natural_baseline;
- gint minimum_above, natural_above;
- gint minimum_below, natural_below;
+ int child_minimum_baseline, child_natural_baseline;
+ int minimum_above, natural_above;
+ int minimum_below, natural_below;
gboolean have_baseline;
- gint extra_space;
- gint children_minimum_size = 0;
- gint size_given_to_child;
- gint n_extra_widgets = 0; /* Number of widgets that receive 1 extra px */
- gint x = 0, y = 0, i;
- gint child_size;
- gint spacing;
+ int extra_space;
+ int children_minimum_size = 0;
+ int size_given_to_child;
+ int n_extra_widgets = 0; /* Number of widgets that receive 1 extra px */
+ int x = 0, y = 0, i;
+ int child_size;
+ int spacing;
count_expand_children (widget, self->orientation, &nvis_children, &nexpand_children);
GPtrArray *gtk_buildable_parse_context_get_element_stack (GtkBuildableParseContext *context);
GDK_AVAILABLE_IN_ALL
void gtk_buildable_parse_context_get_position (GtkBuildableParseContext *context,
- gint *line_number,
- gint *char_number);
+ int *line_number,
+ int *char_number);
G_END_DECLS
GError **error)
{
GtkBuilderMenuState *state = user_data;
- gint i;
+ int i;
for (i = 0; i < text_len; i++)
if (!g_ascii_isspace (text[i]))
gchar *object;
GParamSpec *pspec;
gchar *value;
- gint line;
- gint col;
+ int line;
+ int col;
} DelayedProperty;
typedef struct
GtkBuildableIface *iface;
GtkBuildable *buildable;
gboolean custom_set_property;
- gint i;
+ int i;
g_assert (info->object != NULL);
g_assert (info->type != G_TYPE_INVALID);
}
case G_TYPE_ENUM:
{
- gint enum_value;
+ int enum_value;
if (!_gtk_builder_enum_from_string (type, string, &enum_value, error))
{
ret = FALSE;
gboolean
_gtk_builder_enum_from_string (GType type,
const gchar *string,
- gint *enum_value,
+ int *enum_value,
GError **error)
{
GEnumClass *eclass;
GEnumValue *ev;
gchar *endptr;
- gint value;
+ int value;
gboolean ret;
g_return_val_if_fail (G_TYPE_IS_ENUM (type), FALSE);
GError **error)
{
GtkBuilderPrivate *priv = gtk_builder_get_instance_private (builder);
- gint line, col;
+ int line, col;
gtk_buildable_parse_context_get_position (context, &line, &col);
g_prefix_error (error, "%s:%d:%d ", priv->filename, line, col);
GError **error)
{
GtkBuilderPrivate *priv = gtk_builder_get_instance_private (builder);
- gint line, col;
+ int line, col;
gtk_buildable_parse_context_get_position (context, &line, &col);
g_set_error (error,
{
GtkBuilderPrivate *priv = gtk_builder_get_instance_private (builder);
GPtrArray *stack;
- gint line, col;
+ int line, col;
const gchar *parent;
const gchar *element;
GObject *
gtk_builder_lookup_object (GtkBuilder *builder,
const gchar *name,
- gint line,
- gint col,
+ int line,
+ int col,
GError **error)
{
GtkBuilderPrivate *priv = gtk_builder_get_instance_private (builder);
GObject *
_gtk_builder_lookup_object (GtkBuilder *builder,
const gchar *name,
- gint line,
- gint col)
+ int line,
+ int col)
{
GtkBuilderPrivate *priv = gtk_builder_get_instance_private (builder);
GObject *obj;
*/
void
gtk_buildable_parse_context_get_position (GtkBuildableParseContext *context,
- gint *line_number,
- gint *char_number)
+ int *line_number,
+ int *char_number)
{
if (context->ctx)
const gchar *attribute,
GError **error)
{
- gint line, col;
+ int line, col;
gtk_buildable_parse_context_get_position (&data->ctx, &line, &col);
const gchar *expected,
GError **error)
{
- gint line, col;
+ int line, col;
gtk_buildable_parse_context_get_position (&data->ctx, &line, &col);
const gchar *tag,
GError **error)
{
- gint line, col;
+ int line, col;
gtk_buildable_parse_context_get_position (&data->ctx, &line, &col);
g_set_error (error,
const gchar *library = NULL;
const gchar *version = NULL;
gchar **split;
- gint version_major = 0;
- gint version_minor = 0;
+ int version_major = 0;
+ int version_minor = 0;
if (!g_markup_collect_attributes (element_name, names, values, error,
G_MARKUP_COLLECT_STRING, "lib", &library,
const gchar *type_func = NULL;
const gchar *object_id = NULL;
gchar *internal_id = NULL;
- gint line;
+ int line;
child_info = state_peek_info (data, ChildInfo);
if (child_info && child_info->tag_type == TAG_OBJECT)
ObjectInfo *object_info;
const gchar *object_class = NULL;
const gchar *parent_class = NULL;
- gint line;
+ int line;
GType template_type;
GType parsed_type;
gboolean translatable = FALSE;
ObjectInfo *object_info;
GParamSpec *pspec = NULL;
- gint line, col;
+ int line, col;
object_info = state_peek_info (data, ObjectInfo);
if (!object_info ||
NULL, // error, fails immediately
};
-static gint
+static int
compare_string (gconstpointer _a,
gconstpointer _b)
{
gboolean translatable:1;
gboolean bound:1;
gchar *context;
- gint line;
- gint col;
+ int line;
+ int col;
} PropertyInfo;
typedef struct _ExpressionInfo ExpressionInfo;
gchar *source;
gchar *source_property;
GBindingFlags flags;
- gint line;
- gint col;
+ int line;
+ int col;
} BindingInfo;
typedef struct
GParamSpec *target_pspec;
char *object_name;
ExpressionInfo *expr;
- gint line;
- gint col;
+ int line;
+ int col;
} BindingExpressionInfo;
typedef struct {
guint tag_type;
gchar *library;
- gint major;
- gint minor;
+ int major;
+ int minor;
} RequiresInfo;
struct _GtkBuildableParseContext {
const char **requested_objects; /* NULL if all the objects are requested */
gboolean inside_requested_object;
- gint requested_object_level;
- gint cur_object_level;
+ int requested_object_level;
+ int cur_object_level;
- gint object_counter;
+ int object_counter;
GHashTable *object_ids;
} ParserData;
GError **error);
gboolean _gtk_builder_enum_from_string (GType type,
const gchar *string,
- gint *enum_value,
+ int *enum_value,
GError **error);
gboolean _gtk_builder_flags_from_string (GType type,
GFlagsValue *aliases,
GError **error);
GObject *gtk_builder_lookup_object (GtkBuilder *builder,
const gchar *name,
- gint line,
- gint col,
+ int line,
+ int col,
GError **error);
GObject *_gtk_builder_lookup_object (GtkBuilder *builder,
const gchar *name,
- gint line,
- gint col);
+ int line,
+ int col);
gboolean _gtk_builder_lookup_failed (GtkBuilder *builder,
GError **error);
GModule *gtk_builder_get_module (GtkBuilder *builder);
gboolean split_first_cap)
{
GString *symbol_name = g_string_new ("");
- gint i;
+ int i;
for (i = 0; name[i] != '\0'; i++)
{
GDateTime *date;
- gint day_month[6][7];
- gint day[6][7];
+ int day_month[6][7];
+ int day[6][7];
- gint num_marked_dates;
- gint marked_date[31];
+ int num_marked_dates;
+ int marked_date[31];
- gint focus_row;
- gint focus_col;
+ int focus_row;
+ int focus_col;
- gint week_start;
+ int week_start;
};
struct _GtkCalendarClass
GtkWidget *widget);
static void calendar_invalidate_day (GtkCalendar *widget,
- gint row,
- gint col);
+ int row,
+ int col);
static void calendar_invalidate_day_num (GtkCalendar *widget,
- gint day);
+ int day);
static gboolean gtk_calendar_scroll_controller_scroll (GtkEventControllerScroll *scroll,
gdouble dx,
GtkGesture *gesture;
GtkDragSource *source;
GtkDropTarget *target;
- gint i;
+ int i;
#ifdef G_OS_WIN32
wchar_t wbuffer[100];
#else
gchar *year_before;
#ifdef HAVE__NL_TIME_FIRST_WEEKDAY
union { unsigned int word; char *string; } langinfo;
- gint week_1stday = 0;
- gint first_weekday = 1;
+ int week_1stday = 0;
+ int first_weekday = 1;
guint week_origin;
#else
gchar *week_start;
int day)
{
GDateTime *new_date;
- gint row;
- gint col;
+ int row;
+ int col;
for (row = 0; row < 6; row ++)
for (col = 0; col < 7; col++)
static void
calendar_invalidate_day_num (GtkCalendar *calendar,
- gint day)
+ int day)
{
gtk_widget_queue_draw (GTK_WIDGET (calendar));
}
static void
calendar_invalidate_day (GtkCalendar *calendar,
- gint row,
- gint col)
+ int row,
+ int col)
{
gtk_widget_queue_draw (GTK_WIDGET (calendar));
}
GtkWidget *widget)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
- gint return_val;
- gint old_focus_row;
- gint old_focus_col;
- gint row, col, day;
+ int return_val;
+ int old_focus_row;
+ int old_focus_col;
+ int row, col, day;
return_val = FALSE;
*
* |[<!-- language="C" -->
* GtkTreeIter iter;
- * gint minimum_width;
- * gint natural_width;
+ * int minimum_width;
+ * int natural_width;
*
* valid = gtk_tree_model_get_iter_first (model, &iter);
* while (valid)
* |[<!-- language="C" -->
* static void
* foo_get_preferred_width (GtkWidget *widget,
- * gint *minimum_size,
- * gint *natural_size)
+ * int *minimum_size,
+ * int *natural_size)
* {
* Foo *foo = FOO (widget);
* FooPrivate *priv = foo->priv;
*
* |[<!-- language="C" -->
* GtkTreeIter iter;
- * gint minimum_height;
- * gint natural_height;
- * gint full_minimum_height = 0;
- * gint full_natural_height = 0;
+ * int minimum_height;
+ * int natural_height;
+ * int full_minimum_height = 0;
+ * int full_natural_height = 0;
*
* valid = gtk_tree_model_get_iter_first (model, &iter);
* while (valid)
* GtkAllocation allocation;
* GdkRectangle cell_area = { 0, };
* GtkTreeIter iter;
- * gint minimum_width;
- * gint natural_width;
+ * int minimum_width;
+ * int natural_width;
*
* gtk_widget_get_allocation (widget, &allocation);
* cell_area.width = allocation.width;
* {
* Foo *foo = FOO (widget);
* FooPrivate *priv = foo->priv;
- * gint focus_row;
+ * int focus_row;
* gboolean have_focus = FALSE;
*
* focus_row = priv->focus_row;
const GdkRectangle *background_area,
GtkCellAllocCallback callback,
gpointer callback_data);
-static gint gtk_cell_area_real_event (GtkCellArea *area,
+static int gtk_cell_area_real_event (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
GdkEvent *event,
static void gtk_cell_area_real_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width);
+ int *minimum_width,
+ int *natural_width);
static void gtk_cell_area_real_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height);
+ int *minimum_height,
+ int *natural_height);
static void gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
static void gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
static gboolean gtk_cell_area_real_is_activatable (GtkCellArea *area);
static gboolean gtk_cell_area_real_activate (GtkCellArea *area,
GtkCellAreaContext *context,
static void gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *renderer,
const gchar *attribute,
- gint column);
+ int column);
static void gtk_cell_area_set_cell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkCellLayoutDataFunc func,
GtkCellRenderer *renderer);
static void gtk_cell_area_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position);
+ int position);
static GList *gtk_cell_area_get_cells (GtkCellLayout *cell_layout);
static GtkCellArea *gtk_cell_area_get_area (GtkCellLayout *cell_layout);
/* Used in foreach loop to get a cell by position */
typedef struct {
- gint x;
- gint y;
+ int x;
+ int y;
GtkCellRenderer *renderer;
GdkRectangle cell_area;
} CellByPositionData;
/* Attribute/Cell metadata */
typedef struct {
const gchar *attribute;
- gint column;
+ int column;
} CellAttribute;
typedef struct {
static void cell_info_free (CellInfo *info);
static CellAttribute *cell_attribute_new (GtkCellRenderer *renderer,
const gchar *attribute,
- gint column);
+ int column);
static void cell_attribute_free (CellAttribute *attribute);
-static gint cell_attribute_find (CellAttribute *cell_attribute,
+static int cell_attribute_find (CellAttribute *cell_attribute,
const gchar *attribute);
/* Internal functions/signal emissions */
static CellAttribute *
cell_attribute_new (GtkCellRenderer *renderer,
const gchar *attribute,
- gint column)
+ int column)
{
GParamSpec *pspec;
}
/* GCompareFunc for g_slist_find_custom() */
-static gint
+static int
cell_attribute_find (CellAttribute *cell_attribute,
const gchar *attribute)
{
g_type_name (G_TYPE_FROM_INSTANCE (area)));
}
-static gint
+static int
gtk_cell_area_real_event (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
gtk_cell_area_real_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width)
+ int *minimum_width,
+ int *natural_width)
{
g_warning ("GtkCellAreaClass::get_preferred_width not implemented for '%s'",
g_type_name (G_TYPE_FROM_INSTANCE (area)));
gtk_cell_area_real_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height)
+ int *minimum_height,
+ int *natural_height)
{
g_warning ("GtkCellAreaClass::get_preferred_height not implemented for '%s'",
g_type_name (G_TYPE_FROM_INSTANCE (area)));
gtk_cell_area_real_get_preferred_height_for_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
/* If the area doesnt do height-for-width, fallback on base preferred height */
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_height (area, context, widget, minimum_height, natural_height);
gtk_cell_area_real_get_preferred_width_for_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
/* If the area doesnt do width-for-height, fallback on base preferred width */
GTK_CELL_AREA_GET_CLASS (area)->get_preferred_width (area, context, widget, minimum_width, natural_width);
gtk_cell_area_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *renderer,
const gchar *attribute,
- gint column)
+ int column)
{
gtk_cell_area_attribute_connect (GTK_CELL_AREA (cell_layout),
renderer, attribute, column);
static void
gtk_cell_area_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position)
+ int position)
{
g_warning ("GtkCellLayout::reorder not implemented for '%s'",
g_type_name (G_TYPE_FROM_INSTANCE (cell_layout)));
*
* Returns: %TRUE if the event was handled by @area.
*/
-gint
+int
gtk_cell_area_event (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint x,
- gint y,
+ int x,
+ int y,
GdkRectangle *alloc_area)
{
CellByPositionData data = { x, y, NULL, { 0, } };
gtk_cell_area_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width)
+ int *minimum_width,
+ int *natural_width)
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
GtkCellAreaClass *class;
gtk_cell_area_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height)
+ int *minimum_height,
+ int *natural_height)
{
g_return_if_fail (GTK_IS_CELL_AREA (area));
g_return_if_fail (GTK_IS_WIDGET (widget));
gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
GtkCellAreaClass *class;
gtk_cell_area_attribute_connect (GtkCellArea *area,
GtkCellRenderer *renderer,
const gchar *attribute,
- gint column)
+ int column)
{
GtkCellAreaPrivate *priv = gtk_cell_area_get_instance_private (area);
CellInfo *info;
*
* Returns: the model column, or -1
*/
-gint
+int
gtk_cell_area_attribute_get_column (GtkCellArea *area,
GtkCellRenderer *renderer,
const gchar *attribute)
GtkCellRenderer *renderer,
GtkOrientation orientation,
GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ int for_size,
+ int *minimum_size,
+ int *natural_size)
{
GtkBorder border;
GtkStyleContext *context;
const GdkRectangle *background_area,
GtkCellAllocCallback callback,
gpointer callback_data);
- gint (* event) (GtkCellArea *area,
+ int (* event) (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
GdkEvent *event,
void (* get_preferred_width) (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width);
+ int *minimum_width,
+ int *natural_width);
void (* get_preferred_height_for_width) (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
void (* get_preferred_height) (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height);
+ int *minimum_height,
+ int *natural_height);
void (* get_preferred_width_for_height) (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
/* Cell Properties */
void (* set_cell_property) (GtkCellArea *area,
GtkCellAllocCallback callback,
gpointer callback_data);
GDK_AVAILABLE_IN_ALL
-gint gtk_cell_area_event (GtkCellArea *area,
+int gtk_cell_area_event (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
GdkEvent *event,
GtkCellAreaContext *context,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint x,
- gint y,
+ int x,
+ int y,
GdkRectangle *alloc_area);
/* Geometry */
void gtk_cell_area_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width);
+ int *minimum_width,
+ int *natural_width);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_get_preferred_height_for_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height);
+ int *minimum_height,
+ int *natural_height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_get_preferred_width_for_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
GDK_AVAILABLE_IN_ALL
const gchar * gtk_cell_area_get_current_path_string (GtkCellArea *area);
void gtk_cell_area_attribute_connect (GtkCellArea *area,
GtkCellRenderer *renderer,
const gchar *attribute,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_attribute_disconnect (GtkCellArea *area,
GtkCellRenderer *renderer,
const gchar *attribute);
GDK_AVAILABLE_IN_ALL
-gint gtk_cell_area_attribute_get_column (GtkCellArea *area,
+int gtk_cell_area_attribute_get_column (GtkCellArea *area,
GtkCellRenderer *renderer,
const gchar *attribute);
GtkCellRenderer *renderer,
GtkOrientation orientation,
GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size);
+ int for_size,
+ int *minimum_size,
+ int *natural_size);
/* For api stability, this is called from gtkcelllayout.c in order to ensure the correct
* object is passed to the user function in gtk_cell_layout_set_cell_data_func.
static void gtk_cell_area_box_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width);
+ int *minimum_width,
+ int *natural_width);
static void gtk_cell_area_box_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height);
+ int *minimum_height,
+ int *natural_height);
static void gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
static void gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
static gboolean gtk_cell_area_box_focus (GtkCellArea *area,
GtkDirectionType direction);
gboolean expand);
static void gtk_cell_area_box_layout_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *renderer,
- gint position);
+ int position);
static void gtk_cell_area_box_focus_changed (GtkCellArea *area,
GParamSpec *pspec,
GtkCellAreaBox *box);
typedef struct {
GtkCellRenderer *renderer;
- gint position;
- gint size;
+ int position;
+ int size;
} AllocatedCell;
static CellInfo *cell_info_new (GtkCellRenderer *renderer,
gboolean align,
gboolean fixed);
static void cell_info_free (CellInfo *info);
-static gint cell_info_find (CellInfo *info,
+static int cell_info_find (CellInfo *info,
GtkCellRenderer *renderer);
static AllocatedCell *allocated_cell_new (GtkCellRenderer *renderer,
- gint position,
- gint size);
+ int position,
+ int size);
static void allocated_cell_free (AllocatedCell *cell);
static GList *list_consecutive_cells (GtkCellAreaBox *box);
-static gint count_expand_groups (GtkCellAreaBox *box);
+static int count_expand_groups (GtkCellAreaBox *box);
static void context_weak_notify (GtkCellAreaBox *box,
GtkCellAreaBoxContext *dead_context);
static void reset_contexts (GtkCellAreaBox *box);
static GSList *get_allocated_cells (GtkCellAreaBox *box,
GtkCellAreaBoxContext *context,
GtkWidget *widget,
- gint width,
- gint height);
+ int width,
+ int height);
typedef struct _GtkCellAreaBoxClass GtkCellAreaBoxClass;
typedef struct _GtkCellAreaBoxPrivate GtkCellAreaBoxPrivate;
GSList *contexts;
GtkOrientation orientation;
- gint spacing;
+ int spacing;
/* We hold on to the rtl state from a widget we are requested for
* so that we can navigate focus correctly
g_slice_free (CellInfo, info);
}
-static gint
+static int
cell_info_find (CellInfo *info,
GtkCellRenderer *renderer)
{
static AllocatedCell *
allocated_cell_new (GtkCellRenderer *renderer,
- gint position,
- gint size)
+ int position,
+ int size)
{
AllocatedCell *cell = g_slice_new (AllocatedCell);
cell_groups_clear (GtkCellAreaBox *box)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
- gint i;
+ int i;
for (i = 0; i < priv->groups->len; i++)
{
init_context_groups (box);
}
-static gint
+static int
count_visible_cells (CellGroup *group,
- gint *expand_cells)
+ int *expand_cells)
{
GList *l;
- gint visible_cells = 0;
- gint n_expand_cells = 0;
+ int visible_cells = 0;
+ int n_expand_cells = 0;
for (l = group->cells; l; l = l->next)
{
return visible_cells;
}
-static gint
+static int
count_expand_groups (GtkCellAreaBox *box)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
- gint i;
- gint expand_groups = 0;
+ int i;
+ int expand_groups = 0;
for (i = 0; i < priv->groups->len; i++)
{
GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
- gint *expand_groups, *align_groups, i;
+ int *expand_groups, *align_groups, i;
expand_groups = g_new (gboolean, priv->groups->len);
align_groups = g_new (gboolean, priv->groups->len);
static GSList *
allocate_cells_manually (GtkCellAreaBox *box,
GtkWidget *widget,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
GList *cells, *l;
GSList *allocated_cells = NULL;
GtkRequestedSize *sizes;
- gint i;
- gint nvisible = 0, nexpand = 0, group_expand;
- gint avail_size, extra_size, extra_extra, full_size;
- gint position = 0, for_size;
+ int i;
+ int nvisible = 0, nexpand = 0, group_expand;
+ int avail_size, extra_size, extra_extra, full_size;
+ int position = 0, for_size;
gboolean rtl;
if (!priv->cells)
get_allocated_cells (GtkCellAreaBox *box,
GtkCellAreaBoxContext *context,
GtkWidget *widget,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
GtkCellAreaBoxAllocation *group_allocs;
GtkCellArea *area = GTK_CELL_AREA (box);
GList *cell_list;
GSList *allocated_cells = NULL;
- gint i, j, n_allocs, position;
- gint for_size, full_size;
+ int i, j, n_allocs, position;
+ int for_size, full_size;
gboolean rtl;
group_allocs = _gtk_cell_area_box_context_get_orientation_allocs (context, &n_allocs);
{
CellInfo *info = group->cells->data;
AllocatedCell *cell;
- gint cell_position, cell_size;
+ int cell_position, cell_size;
if (!gtk_cell_renderer_get_visible (info->renderer))
continue;
cell_size = group_allocs[i].size;
else
{
- gint dummy;
+ int dummy;
gtk_cell_area_request_renderer (area, info->renderer,
priv->orientation,
widget, for_size,
else
{
GtkRequestedSize *sizes;
- gint avail_size, cell_position;
- gint visible_cells, expand_cells;
- gint extra_size, extra_extra;
+ int avail_size, cell_position;
+ int visible_cells, expand_cells;
+ int extra_size, extra_extra;
visible_cells = count_visible_cells (group, &expand_cells);
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
- gint i;
+ int i;
/* Call the parent class to apply the attributes */
GTK_CELL_AREA_CLASS
GtkOrientation orientation,
GtkCellAreaBoxContext *context,
GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ int for_size,
+ int *minimum_size,
+ int *natural_size)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
GtkCellArea *area = GTK_CELL_AREA (box);
GList *list;
- gint i;
- gint min_size = 0;
- gint nat_size = 0;
+ int i;
+ int min_size = 0;
+ int nat_size = 0;
for (i = 0; i < priv->groups->len; i++)
{
CellGroup *group = &g_array_index (priv->groups, CellGroup, i);
- gint group_min_size = 0;
- gint group_nat_size = 0;
+ int group_min_size = 0;
+ int group_nat_size = 0;
for (list = group->cells; list; list = list->next)
{
CellInfo *info = list->data;
- gint renderer_min_size, renderer_nat_size;
+ int renderer_min_size, renderer_nat_size;
if (!gtk_cell_renderer_get_visible (info->renderer))
continue;
CellGroup *group,
GtkOrientation orientation,
GtkWidget *widget,
- gint *n_sizes)
+ int *n_sizes)
{
GtkRequestedSize *sizes;
GList *l;
- gint i;
+ int i;
*n_sizes = count_visible_cells (group, NULL);
sizes = g_new (GtkRequestedSize, *n_sizes);
compute_group_size_for_opposing_orientation (GtkCellAreaBox *box,
CellGroup *group,
GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ int for_size,
+ int *minimum_size,
+ int *natural_size)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
GtkCellArea *area = GTK_CELL_AREA (box);
{
GtkRequestedSize *orientation_sizes;
CellInfo *info;
- gint n_sizes, i;
- gint avail_size = for_size;
- gint extra_size, extra_extra;
- gint min_size = 0, nat_size = 0;
+ int n_sizes, i;
+ int avail_size = for_size;
+ int extra_size, extra_extra;
+ int min_size = 0, nat_size = 0;
orientation_sizes = get_group_sizes (area, group, priv->orientation, widget, &n_sizes);
for (i = 0; i < n_sizes; i++)
{
- gint cell_min, cell_nat;
+ int cell_min, cell_nat;
info = orientation_sizes[i].data;
compute_size_for_opposing_orientation (GtkCellAreaBox *box,
GtkCellAreaBoxContext *context,
GtkWidget *widget,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ int for_size,
+ int *minimum_size,
+ int *natural_size)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
CellGroup *group;
GtkRequestedSize *orientation_sizes;
- gint n_groups, n_expand_groups, i;
- gint avail_size = for_size;
- gint extra_size, extra_extra;
- gint min_size = 0, nat_size = 0;
+ int n_groups, n_expand_groups, i;
+ int avail_size = for_size;
+ int extra_size, extra_extra;
+ int min_size = 0, nat_size = 0;
n_expand_groups = count_expand_groups (box);
*/
for (i = 0; i < n_groups; i++)
{
- gint group_min, group_nat;
- gint group_idx = GPOINTER_TO_INT (orientation_sizes[i].data);
+ int group_min, group_nat;
+ int group_idx = GPOINTER_TO_INT (orientation_sizes[i].data);
group = &g_array_index (priv->groups, CellGroup, group_idx);
gtk_cell_area_box_get_preferred_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_width,
- gint *natural_width)
+ int *minimum_width,
+ int *natural_width)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxContext *box_context;
- gint min_width, nat_width;
+ int min_width, nat_width;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (context));
gtk_cell_area_box_get_preferred_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint *minimum_height,
- gint *natural_height)
+ int *minimum_height,
+ int *natural_height)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxContext *box_context;
- gint min_height, nat_height;
+ int min_height, nat_height;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (context));
gtk_cell_area_box_get_preferred_height_for_width (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
- gint min_height, nat_height;
+ int min_height, nat_height;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (context));
gtk_cell_area_box_get_preferred_width_for_height (GtkCellArea *area,
GtkCellAreaContext *context,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
- gint min_width, nat_width;
+ int min_width, nat_width;
g_return_if_fail (GTK_IS_CELL_AREA_BOX_CONTEXT (context));
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (area);
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
- gint cycle = FOCUS_NONE;
+ int cycle = FOCUS_NONE;
gboolean cycled_focus = FALSE;
GtkCellRenderer *focus_cell;
{
gboolean found_cell = FALSE;
GList *list;
- gint i;
+ int i;
/* If there is no focused cell, focus on the first (or last) one */
if (!focus_cell)
static void
gtk_cell_area_box_layout_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *renderer,
- gint position)
+ int position)
{
GtkCellAreaBox *box = GTK_CELL_AREA_BOX (cell_layout);
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
*************************************************************/
gboolean
_gtk_cell_area_box_group_visible (GtkCellAreaBox *box,
- gint group_idx)
+ int group_idx)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
CellGroup *group;
*
* Returns: the space added between cell renderers in @box.
*/
-gint
+int
gtk_cell_area_box_get_spacing (GtkCellAreaBox *box)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
*/
void
gtk_cell_area_box_set_spacing (GtkCellAreaBox *box,
- gint spacing)
+ int spacing)
{
GtkCellAreaBoxPrivate *priv = gtk_cell_area_box_get_instance_private (box);
gboolean align,
gboolean fixed);
GDK_AVAILABLE_IN_ALL
-gint gtk_cell_area_box_get_spacing (GtkCellAreaBox *box);
+int gtk_cell_area_box_get_spacing (GtkCellAreaBox *box);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_box_set_spacing (GtkCellAreaBox *box,
- gint spacing);
+ int spacing);
/* Private interaction with GtkCellAreaBoxContext */
gboolean _gtk_cell_area_box_group_visible (GtkCellAreaBox *box,
- gint group_idx);
+ int group_idx);
G_END_DECLS
/* GtkCellAreaContextClass */
static void _gtk_cell_area_box_context_reset (GtkCellAreaContext *context);
static void _gtk_cell_area_box_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
static void _gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
/* Internal functions */
static void _gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
GtkOrientation orientation,
- gint for_size,
- gint *minimum_size,
- gint *natural_size);
+ int for_size,
+ int *minimum_size,
+ int *natural_size);
static void free_cache_array (GArray *array);
static GArray *group_array_new (GtkCellAreaBoxContext *context);
static GArray *get_array (GtkCellAreaBoxContext *context,
GtkOrientation orientation,
- gint for_size);
+ int for_size);
static gboolean group_expands (GtkCellAreaBoxContext *context,
- gint group_idx);
-static gint count_expand_groups (GtkCellAreaBoxContext *context);
+ int group_idx);
+static int count_expand_groups (GtkCellAreaBoxContext *context);
/* CachedSize management */
typedef struct {
- gint min_size;
- gint nat_size;
+ int min_size;
+ int nat_size;
} CachedSize;
struct _GtkCellAreaBoxContextPrivate
static GArray *
get_array (GtkCellAreaBoxContext *context,
GtkOrientation orientation,
- gint for_size)
+ int for_size)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GArray *array;
static gboolean
group_expands (GtkCellAreaBoxContext *context,
- gint group_idx)
+ int group_idx)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
return priv->expand[group_idx];
}
-static gint
+static int
count_expand_groups (GtkCellAreaBoxContext *context)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
- gint i, expand = 0;
+ int i, expand = 0;
for (i = 0; i < priv->base_widths->len; i++)
{
GtkCellAreaBoxContext *box_context = GTK_CELL_AREA_BOX_CONTEXT (context);
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
CachedSize *size;
- gint i;
+ int i;
for (i = 0; i < priv->base_widths->len; i++)
{
static void
_gtk_cell_area_box_context_sum (GtkCellAreaBoxContext *context,
GtkOrientation orientation,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ int for_size,
+ int *minimum_size,
+ int *natural_size)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GtkCellAreaBox *area;
GtkOrientation box_orientation;
GArray *array;
- gint spacing, i, last_aligned_group_idx;
- gint min_size = 0, nat_size = 0;
+ int spacing, i, last_aligned_group_idx;
+ int min_size = 0, nat_size = 0;
area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (context));
spacing = gtk_cell_area_box_get_spacing (area);
static void
_gtk_cell_area_box_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
_gtk_cell_area_box_context_sum (GTK_CELL_AREA_BOX_CONTEXT (context), GTK_ORIENTATION_VERTICAL,
width, minimum_height, natural_height);
static void
_gtk_cell_area_box_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
_gtk_cell_area_box_context_sum (GTK_CELL_AREA_BOX_CONTEXT (context), GTK_ORIENTATION_HORIZONTAL,
height, minimum_width, natural_width);
copy_size_array (GArray *src_array,
GArray *dest_array)
{
- gint i;
+ int i;
for (i = 0; i < src_array->len; i++)
{
void
_gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_width,
- gint natural_width)
+ int group_idx,
+ int minimum_width,
+ int natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
void
_gtk_cell_area_box_context_push_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint minimum_height,
- gint natural_height)
+ int group_idx,
+ int for_width,
+ int minimum_height,
+ int natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
void
_gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_height,
- gint natural_height)
+ int group_idx,
+ int minimum_height,
+ int natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
void
_gtk_cell_area_box_context_push_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint minimum_width,
- gint natural_width)
+ int group_idx,
+ int for_height,
+ int minimum_width,
+ int natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
void
_gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_width,
- gint *natural_width)
+ int group_idx,
+ int *minimum_width,
+ int *natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
void
_gtk_cell_area_box_context_get_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint *minimum_height,
- gint *natural_height)
+ int group_idx,
+ int for_width,
+ int *minimum_height,
+ int *natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
void
_gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_height,
- gint *natural_height)
+ int group_idx,
+ int *minimum_height,
+ int *natural_height)
{
GtkCellAreaBoxContextPrivate *priv;
CachedSize *size;
void
_gtk_cell_area_box_context_get_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint *minimum_width,
- gint *natural_width)
+ int group_idx,
+ int for_height,
+ int *minimum_width,
+ int *natural_width)
{
GtkCellAreaBoxContextPrivate *priv;
GArray *group_array;
_gtk_cell_area_box_context_get_requests (GtkCellAreaBoxContext *box_context,
GtkCellAreaBox *area,
GtkOrientation orientation,
- gint for_size,
- gint *n_requests)
+ int for_size,
+ int *n_requests)
{
GtkCellAreaBoxContextPrivate *priv = box_context->priv;
GtkRequestedSize *requests;
GArray *array;
CachedSize *size;
- gint visible_groups = 0;
- gint last_aligned_group_idx = 0;
- gint i, j;
+ int visible_groups = 0;
+ int last_aligned_group_idx = 0;
+ int i, j;
/* Get the last visible aligned group
* (we need to get space at least up till this group) */
allocate_for_orientation (GtkCellAreaBoxContext *context,
GtkCellAreaBox *area,
GtkOrientation orientation,
- gint spacing,
- gint size,
- gint for_size,
- gint *n_allocs)
+ int spacing,
+ int size,
+ int for_size,
+ int *n_allocs)
{
GtkCellAreaBoxContextPrivate *priv = context->priv;
GtkCellAreaBoxAllocation *allocs;
GtkRequestedSize *sizes;
- gint n_expand_groups = 0;
- gint i, n_groups, position, vis_position;
- gint extra_size, extra_extra;
- gint avail_size = size;
+ int n_expand_groups = 0;
+ int i, n_groups, position, vis_position;
+ int extra_size, extra_extra;
+ int avail_size = size;
sizes = _gtk_cell_area_box_context_get_requests (context, area, orientation, for_size, &n_groups);
n_expand_groups = count_expand_groups (context);
GtkRequestedSize *
_gtk_cell_area_box_context_get_widths (GtkCellAreaBoxContext *box_context,
- gint *n_widths)
+ int *n_widths)
{
GtkCellAreaBox *area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (box_context));
GtkRequestedSize *
_gtk_cell_area_box_context_get_heights (GtkCellAreaBoxContext *box_context,
- gint *n_heights)
+ int *n_heights)
{
GtkCellAreaBox *area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (GTK_CELL_AREA_CONTEXT (box_context));
GtkCellAreaBoxAllocation *
_gtk_cell_area_box_context_get_orientation_allocs (GtkCellAreaBoxContext *context,
- gint *n_allocs)
+ int *n_allocs)
{
GtkCellAreaContext *ctx = GTK_CELL_AREA_CONTEXT (context);
GtkCellAreaBox *area;
GtkOrientation orientation;
- gint spacing, width, height, alloc_count = 0;
+ int spacing, width, height, alloc_count = 0;
GtkCellAreaBoxAllocation *allocs = NULL;
area = (GtkCellAreaBox *)gtk_cell_area_context_get_area (ctx);
/* Update cell-group sizes */
void _gtk_cell_area_box_context_push_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_width,
- gint natural_width);
+ int group_idx,
+ int minimum_width,
+ int natural_width);
void _gtk_cell_area_box_context_push_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint minimum_height,
- gint natural_height);
+ int group_idx,
+ int for_width,
+ int minimum_height,
+ int natural_height);
void _gtk_cell_area_box_context_push_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint minimum_height,
- gint natural_height);
+ int group_idx,
+ int minimum_height,
+ int natural_height);
void _gtk_cell_area_box_context_push_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint minimum_width,
- gint natural_width);
+ int group_idx,
+ int for_height,
+ int minimum_width,
+ int natural_width);
/* Fetch cell-group sizes */
void _gtk_cell_area_box_context_get_group_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_width,
- gint *natural_width);
+ int group_idx,
+ int *minimum_width,
+ int *natural_width);
void _gtk_cell_area_box_context_get_group_height_for_width (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_width,
- gint *minimum_height,
- gint *natural_height);
+ int group_idx,
+ int for_width,
+ int *minimum_height,
+ int *natural_height);
void _gtk_cell_area_box_context_get_group_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint *minimum_height,
- gint *natural_height);
+ int group_idx,
+ int *minimum_height,
+ int *natural_height);
void _gtk_cell_area_box_context_get_group_width_for_height (GtkCellAreaBoxContext *box_context,
- gint group_idx,
- gint for_height,
- gint *minimum_width,
- gint *natural_width);
+ int group_idx,
+ int for_height,
+ int *minimum_width,
+ int *natural_width);
GtkRequestedSize *_gtk_cell_area_box_context_get_widths (GtkCellAreaBoxContext *box_context,
- gint *n_widths);
+ int *n_widths);
GtkRequestedSize *_gtk_cell_area_box_context_get_heights (GtkCellAreaBoxContext *box_context,
- gint *n_heights);
+ int *n_heights);
/* Private context/area interaction */
typedef struct {
- gint group_idx; /* Groups containing only invisible cells are not allocated */
- gint position; /* Relative group allocation position in the orientation of the box */
- gint size; /* Full allocated size of the cells in this group spacing inclusive */
+ int group_idx; /* Groups containing only invisible cells are not allocated */
+ int position; /* Relative group allocation position in the orientation of the box */
+ int size; /* Full allocated size of the cells in this group spacing inclusive */
} GtkCellAreaBoxAllocation;
GtkCellAreaBoxAllocation *
_gtk_cell_area_box_context_get_orientation_allocs (GtkCellAreaBoxContext *context,
- gint *n_allocs);
+ int *n_allocs);
G_END_DECLS
/* GtkCellAreaContextClass */
static void gtk_cell_area_context_real_reset (GtkCellAreaContext *context);
static void gtk_cell_area_context_real_allocate (GtkCellAreaContext *context,
- gint width,
- gint height);
+ int width,
+ int height);
typedef struct _GtkCellAreaContextPrivate GtkCellAreaContextPrivate;
struct _GtkCellAreaContextPrivate
{
GtkCellArea *cell_area;
- gint min_width;
- gint nat_width;
- gint min_height;
- gint nat_height;
- gint alloc_width;
- gint alloc_height;
+ int min_width;
+ int nat_width;
+ int min_height;
+ int nat_height;
+ int alloc_width;
+ int alloc_height;
};
enum {
static void
gtk_cell_area_context_real_allocate (GtkCellAreaContext *context,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkCellAreaContextPrivate *priv = gtk_cell_area_context_get_instance_private (context);
*/
void
gtk_cell_area_context_allocate (GtkCellAreaContext *context,
- gint width,
- gint height)
+ int width,
+ int height)
{
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
*/
void
gtk_cell_area_context_get_preferred_width (GtkCellAreaContext *context,
- gint *minimum_width,
- gint *natural_width)
+ int *minimum_width,
+ int *natural_width)
{
GtkCellAreaContextPrivate *priv = gtk_cell_area_context_get_instance_private (context);
*/
void
gtk_cell_area_context_get_preferred_height (GtkCellAreaContext *context,
- gint *minimum_height,
- gint *natural_height)
+ int *minimum_height,
+ int *natural_height)
{
GtkCellAreaContextPrivate *priv = gtk_cell_area_context_get_instance_private (context);
*/
void
gtk_cell_area_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
*/
void
gtk_cell_area_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
g_return_if_fail (GTK_IS_CELL_AREA_CONTEXT (context));
*/
void
gtk_cell_area_context_get_allocation (GtkCellAreaContext *context,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkCellAreaContextPrivate *priv = gtk_cell_area_context_get_instance_private (context);
*/
void
gtk_cell_area_context_push_preferred_width (GtkCellAreaContext *context,
- gint minimum_width,
- gint natural_width)
+ int minimum_width,
+ int natural_width)
{
GtkCellAreaContextPrivate *priv = gtk_cell_area_context_get_instance_private (context);
*/
void
gtk_cell_area_context_push_preferred_height (GtkCellAreaContext *context,
- gint minimum_height,
- gint natural_height)
+ int minimum_height,
+ int natural_height)
{
GtkCellAreaContextPrivate *priv = gtk_cell_area_context_get_instance_private (context);
/*< public >*/
void (* allocate) (GtkCellAreaContext *context,
- gint width,
- gint height);
+ int width,
+ int height);
void (* reset) (GtkCellAreaContext *context);
void (* get_preferred_height_for_width) (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
void (* get_preferred_width_for_height) (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
/*< private >*/
GtkCellArea *gtk_cell_area_context_get_area (GtkCellAreaContext *context);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_allocate (GtkCellAreaContext *context,
- gint width,
- gint height);
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_reset (GtkCellAreaContext *context);
*/
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_get_preferred_width (GtkCellAreaContext *context,
- gint *minimum_width,
- gint *natural_width);
+ int *minimum_width,
+ int *natural_width);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_get_preferred_height (GtkCellAreaContext *context,
- gint *minimum_height,
- gint *natural_height);
+ int *minimum_height,
+ int *natural_height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_get_preferred_height_for_width (GtkCellAreaContext *context,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_get_preferred_width_for_height (GtkCellAreaContext *context,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_get_allocation (GtkCellAreaContext *context,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
/* Apis for GtkCellArea implementations to update cached values
* for multiple GtkTreeModel rows
*/
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_push_preferred_width (GtkCellAreaContext *context,
- gint minimum_width,
- gint natural_width);
+ int minimum_width,
+ int natural_width);
GDK_AVAILABLE_IN_ALL
void gtk_cell_area_context_push_preferred_height (GtkCellAreaContext *context,
- gint minimum_height,
- gint natural_height);
+ int minimum_height,
+ int natural_height);
G_END_DECLS
static void gtk_cell_layout_default_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
- gint column);
+ int column);
static void gtk_cell_layout_default_set_cell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkCellLayoutDataFunc func,
GtkCellRenderer *cell);
static void gtk_cell_layout_default_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position);
+ int position);
static GList *gtk_cell_layout_default_get_cells (GtkCellLayout *cell_layout);
gtk_cell_layout_default_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
- gint column)
+ int column)
{
GtkCellLayoutIface *iface;
GtkCellArea *area;
static void
gtk_cell_layout_default_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position)
+ int position)
{
GtkCellLayoutIface *iface;
GtkCellArea *area;
va_list args)
{
gchar *attribute;
- gint column;
+ int column;
attribute = va_arg (args, gchar *);
while (attribute != NULL)
{
- column = va_arg (args, gint);
+ column = va_arg (args, int);
gtk_cell_layout_add_attribute (cell_layout, cell, attribute, column);
gtk_cell_layout_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
- gint column)
+ int column)
{
g_return_if_fail (GTK_IS_CELL_LAYOUT (cell_layout));
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
void
gtk_cell_layout_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position)
+ int position)
{
g_return_if_fail (GTK_IS_CELL_LAYOUT (cell_layout));
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
void (* add_attribute) (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
- gint column);
+ int column);
void (* set_cell_data_func) (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GtkCellLayoutDataFunc func,
GtkCellRenderer *cell);
void (* reorder) (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position);
+ int position);
GList* (* get_cells) (GtkCellLayout *cell_layout);
GtkCellArea *(* get_area) (GtkCellLayout *cell_layout);
void gtk_cell_layout_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
void gtk_cell_layout_set_cell_data_func (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
GDK_AVAILABLE_IN_ALL
void gtk_cell_layout_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
GtkCellArea *gtk_cell_layout_get_area (GtkCellLayout *cell_layout);
static GtkSizeRequestMode gtk_cell_renderer_real_get_request_mode(GtkCellRenderer *cell);
static void gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
static void gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
static void gtk_cell_renderer_real_get_preferred_height_for_width(GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
static void gtk_cell_renderer_real_get_preferred_width_for_height(GtkCellRenderer *cell,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
static void gtk_cell_renderer_real_get_aligned_area (GtkCellRenderer *cell,
GtkWidget *widget,
GtkCellRendererState flags,
gfloat xalign;
gfloat yalign;
- gint width;
- gint height;
+ int width;
+ int height;
guint16 xpad;
guint16 ypad;
LAST_SIGNAL
};
-static gint GtkCellRenderer_private_offset;
+static int GtkCellRenderer_private_offset;
static guint cell_renderer_signals[LAST_SIGNAL] = { 0 };
static inline gpointer
**/
void
gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkCellRendererPrivate *priv;
**/
void
gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkCellRendererPrivate *priv;
**/
void
gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
- gint xpad,
- gint ypad)
+ int xpad,
+ int ypad)
{
GtkCellRendererPrivate *priv;
**/
void
gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
- gint *xpad,
- gint *ypad)
+ int *xpad,
+ int *ypad)
{
GtkCellRendererPrivate *priv;
gtk_cell_renderer_real_get_preferred_size (GtkCellRenderer *cell,
GtkWidget *widget,
GtkOrientation orientation,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
GtkRequisition min_req;
static void
gtk_cell_renderer_real_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_HORIZONTAL,
minimum_size, natural_size);
static void
gtk_cell_renderer_real_get_preferred_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
gtk_cell_renderer_real_get_preferred_size (cell, widget, GTK_ORIENTATION_VERTICAL,
minimum_size, natural_size);
static void
gtk_cell_renderer_real_get_preferred_height_for_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
/* Fall back on the height reported from ->get_size() */
gtk_cell_renderer_get_preferred_height (cell, widget, minimum_height, natural_height);
static void
gtk_cell_renderer_real_get_preferred_width_for_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
/* Fall back on the width reported from ->get_size() */
gtk_cell_renderer_get_preferred_width (cell, widget, minimum_width, natural_width);
const GdkRectangle *cell_area,
GdkRectangle *aligned_area)
{
- gint opposite_size, x_offset, y_offset;
- gint natural_size;
+ int opposite_size, x_offset, y_offset;
+ int natural_size;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_IS_WIDGET (widget));
_gtk_cell_renderer_calc_offset (GtkCellRenderer *cell,
const GdkRectangle *cell_area,
GtkTextDirection direction,
- gint width,
- gint height,
- gint *x_offset,
- gint *y_offset)
+ int width,
+ int height,
+ int *x_offset,
+ int *y_offset)
{
GtkCellRendererPrivate *priv;
void
gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
GtkCellRendererClass *klass;
- gint width;
+ int width;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_IS_WIDGET (widget));
void
gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
GtkCellRendererClass *klass;
- gint height;
+ int height;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_IS_WIDGET (widget));
void
gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width)
+ int height,
+ int *minimum_width,
+ int *natural_width)
{
GtkCellRendererClass *klass;
- gint width;
+ int width;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_IS_WIDGET (widget));
void
gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
GtkCellRendererClass *klass;
- gint height;
+ int height;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_IS_WIDGET (widget));
GtkRequisition *minimum_size,
GtkRequisition *natural_size)
{
- gint min_width, nat_width;
- gint min_height, nat_height;
+ int min_width, nat_width;
+ int min_height, nat_height;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
GtkSizeRequestMode (* get_request_mode) (GtkCellRenderer *cell);
void (* get_preferred_width) (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
void (* get_preferred_height_for_width) (GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
void (* get_preferred_height) (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
void (* get_preferred_width_for_height) (GtkCellRenderer *cell,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
void (* get_aligned_area) (GtkCellRenderer *cell,
GtkWidget *widget,
GtkCellRendererState flags,
void (* get_size) (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height);
void (* snapshot) (GtkCellRenderer *cell,
GtkSnapshot *snapshot,
GtkWidget *widget,
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint height,
- gint *minimum_width,
- gint *natural_width);
+ int height,
+ int *minimum_width,
+ int *natural_width);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell,
GtkWidget *widget,
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
- gint width,
- gint height);
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
- gint xpad,
- gint ypad);
+ int xpad,
+ int ypad);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
- gint *xpad,
- gint *ypad);
+ int *xpad,
+ int *ypad);
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
void _gtk_cell_renderer_calc_offset (GtkCellRenderer *cell,
const GdkRectangle *cell_area,
GtkTextDirection direction,
- gint width,
- gint height,
- gint *x_offset,
- gint *y_offset);
+ int width,
+ int height,
+ int *x_offset,
+ int *y_offset);
GDK_AVAILABLE_IN_ALL
GtkStateFlags gtk_cell_renderer_get_state (GtkCellRenderer *cell,
static void gtk_cell_renderer_accel_get_preferred_width
(GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
static GtkCellEditable *
gtk_cell_renderer_accel_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
static void
gtk_cell_renderer_accel_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
GtkCellRendererAccelPrivate *priv = gtk_cell_renderer_accel_get_instance_private (GTK_CELL_RENDERER_ACCEL (cell));
gboolean has_entry;
- gint text_column;
+ int text_column;
gulong focus_out_id;
};
static void gtk_cell_renderer_pixbuf_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *rectangle,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height);
static void gtk_cell_renderer_pixbuf_snapshot (GtkCellRenderer *cell,
GtkSnapshot *snapshot,
GtkWidget *widget,
gtk_cell_renderer_pixbuf_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height)
{
GtkCellRendererPixbuf *cellpixbuf = GTK_CELL_RENDERER_PIXBUF (cell);
GtkCellRendererPixbufPrivate *priv = gtk_cell_renderer_pixbuf_get_instance_private (cellpixbuf);
- gint pixbuf_width;
- gint pixbuf_height;
- gint calc_width;
- gint calc_height;
- gint xpad, ypad;
+ int pixbuf_width;
+ int pixbuf_height;
+ int calc_width;
+ int calc_height;
+ int xpad, ypad;
GtkStyleContext *context;
GtkIconHelper *icon_helper;
}
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
- calc_width = (gint) xpad * 2 + pixbuf_width;
- calc_height = (gint) ypad * 2 + pixbuf_height;
+ calc_width = (int) xpad * 2 + pixbuf_width;
+ calc_height = (int) ypad * 2 + pixbuf_height;
if (cell_area && pixbuf_width > 0 && pixbuf_height > 0)
{
GtkStyleContext *context;
GdkRectangle pix_rect;
gboolean is_expander;
- gint xpad, ypad;
+ int xpad, ypad;
GtkIconHelper *icon_helper;
gtk_cell_renderer_pixbuf_get_size (cell, widget, (GdkRectangle *) cell_area,
struct _GtkCellRendererProgressPrivate
{
- gint value;
+ int value;
gchar *text;
gchar *label;
- gint min_h;
- gint min_w;
- gint pulse;
- gint offset;
+ int min_h;
+ int min_w;
+ int pulse;
+ int offset;
gfloat text_xalign;
gfloat text_yalign;
GtkOrientation orientation;
const GValue *value,
GParamSpec *pspec);
static void gtk_cell_renderer_progress_set_value (GtkCellRendererProgress *cellprogress,
- gint value);
+ int value);
static void gtk_cell_renderer_progress_set_text (GtkCellRendererProgress *cellprogress,
const gchar *text);
static void gtk_cell_renderer_progress_set_pulse (GtkCellRendererProgress *cellprogress,
- gint pulse);
+ int pulse);
static void compute_dimensions (GtkCellRenderer *cell,
GtkWidget *widget,
const gchar *text,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
static void gtk_cell_renderer_progress_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height);
static void gtk_cell_renderer_progress_snapshot (GtkCellRenderer *cell,
GtkSnapshot *snapshot,
GtkWidget *widget,
static void
gtk_cell_renderer_progress_set_value (GtkCellRendererProgress *cellprogress,
- gint value)
+ int value)
{
GtkCellRendererProgressPrivate *priv = gtk_cell_renderer_progress_get_instance_private (cellprogress);
static void
gtk_cell_renderer_progress_set_pulse (GtkCellRendererProgress *cellprogress,
- gint pulse)
+ int pulse)
{
GtkCellRendererProgressPrivate *priv = gtk_cell_renderer_progress_get_instance_private (cellprogress);
compute_dimensions (GtkCellRenderer *cell,
GtkWidget *widget,
const gchar *text,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
PangoRectangle logical_rect;
PangoLayout *layout;
- gint xpad, ypad;
+ int xpad, ypad;
layout = gtk_widget_create_pango_layout (widget, text);
pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
gtk_cell_renderer_progress_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height)
{
GtkCellRendererProgress *cellprogress = GTK_CELL_RENDERER_PROGRESS (cell);
GtkCellRendererProgressPrivate *priv = gtk_cell_renderer_progress_get_instance_private (cellprogress);
- gint w, h;
+ int w, h;
gchar *text;
if (priv->min_w < 0)
if (y_offset) *y_offset = 0;
}
-static inline gint
-get_bar_size (gint pulse,
- gint value,
- gint full_size)
+static inline int
+get_bar_size (int pulse,
+ int value,
+ int full_size)
{
- gint bar_size;
+ int bar_size;
if (pulse < 0)
bar_size = full_size * MAX (0, value) / 100;
return bar_size;
}
-static inline gint
-get_bar_position (gint start,
- gint full_size,
- gint bar_size,
- gint pulse,
- gint offset,
+static inline int
+get_bar_position (int start,
+ int full_size,
+ int bar_size,
+ int pulse,
+ int offset,
gboolean is_rtl)
{
- gint position;
+ int position;
if (pulse < 0 || pulse == 0 || pulse == G_MAXINT)
{
GtkBorder padding;
PangoLayout *layout;
PangoRectangle logical_rect;
- gint x, y, w, h, x_pos, y_pos, bar_position, bar_size, start, full_size;
- gint xpad, ypad;
+ int x, y, w, h, x_pos, y_pos, bar_position, bar_size, start, full_size;
+ int xpad, ypad;
GdkRectangle clip;
gboolean is_rtl;
gboolean active;
guint pulse;
GtkIconSize icon_size;
- gint size;
+ int size;
};
static void gtk_cell_renderer_spinner_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height);
static void gtk_cell_renderer_spinner_snapshot (GtkCellRenderer *cell,
GtkSnapshot *snapshot,
GtkWidget *widget,
gtk_cell_renderer_spinner_get_size (GtkCellRenderer *cellr,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height)
{
GtkCellRendererSpinner *cell = GTK_CELL_RENDERER_SPINNER (cellr);
GtkCellRendererSpinnerPrivate *priv = gtk_cell_renderer_spinner_get_instance_private (cell);
gdouble align;
- gint w, h;
- gint xpad, ypad;
+ int w, h;
+ int xpad, ypad;
gfloat xalign, yalign;
gboolean rtl;
gtk_paint_spinner (GtkStyleContext *context,
cairo_t *cr,
guint step,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
GdkRGBA color;
guint num_steps;
gdouble dx, dy;
gdouble radius;
gdouble half;
- gint i;
+ int i;
guint real_step;
num_steps = 12;
for (i = 0; i < num_steps; i++)
{
- gint inset = 0.7 * radius;
+ int inset = 0.7 * radius;
/* transparency is a function of time and initial value */
gdouble t = (gdouble) ((i + num_steps - real_step)
GtkCellRendererSpinnerPrivate *priv = gtk_cell_renderer_spinner_get_instance_private (cell);
GdkRectangle pix_rect;
GdkRectangle draw_rect;
- gint xpad, ypad;
+ int xpad, ypad;
cairo_t *cr;
if (!priv->active)
static void gtk_cell_renderer_text_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimal_size,
- gint *natural_size);
+ int *minimal_size,
+ int *natural_size);
static void gtk_cell_renderer_text_get_preferred_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimal_size,
- gint *natural_size);
+ int *minimal_size,
+ int *natural_size);
static void gtk_cell_renderer_text_get_preferred_height_for_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height);
+ int width,
+ int *minimum_height,
+ int *natural_height);
static void gtk_cell_renderer_text_get_aligned_area (GtkCellRenderer *cell,
GtkWidget *widget,
GtkCellRendererState flags,
gdouble font_scale;
- gint rise;
- gint fixed_height_rows;
- gint width_chars;
- gint max_width_chars;
- gint wrap_width;
+ int rise;
+ int fixed_height_rows;
+ int width_chars;
+ int max_width_chars;
+ int wrap_width;
guint in_entry_menu : 1;
guint strikethrough : 1;
pango_font_description_set_stretch (desc, pango_font_description_get_stretch (desc));
if (to_set & PANGO_FONT_MASK_SIZE)
{
- gint size = pango_font_description_get_size (desc);
+ int size = pango_font_description_get_size (desc);
if (size <= 0)
{
size = 10 * PANGO_SCALE;
PangoAttrList *attr_list;
PangoLayout *layout;
PangoUnderline uline;
- gint xpad;
+ int xpad;
gboolean placeholder_layout = show_placeholder_text (celltext);
layout = gtk_widget_create_pango_layout (widget, placeholder_layout ?
if (priv->wrap_width != -1)
{
PangoRectangle rect;
- gint width, text_width;
+ int width, text_width;
pango_layout_get_extents (layout, NULL, &rect);
text_width = rect.width;
GtkWidget *widget,
const GdkRectangle *cell_area,
PangoLayout *layout,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
GtkCellRendererTextPrivate *priv = gtk_cell_renderer_text_get_instance_private (celltext);
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *font_desc;
- gint row_height;
+ int row_height;
style_context = gtk_widget_get_style_context (widget);
GtkCellRendererTextPrivate *priv = gtk_cell_renderer_text_get_instance_private (celltext);
GtkStyleContext *context;
PangoLayout *layout;
- gint x_offset = 0;
- gint y_offset = 0;
- gint xpad, ypad;
+ int x_offset = 0;
+ int y_offset = 0;
+ int xpad, ypad;
PangoRectangle rect;
layout = get_layout (celltext, widget, cell_area, flags);
**/
void
gtk_cell_renderer_text_set_fixed_height_from_font (GtkCellRendererText *renderer,
- gint number_of_rows)
+ int number_of_rows)
{
GtkCellRendererTextPrivate *priv = gtk_cell_renderer_text_get_instance_private (renderer);
GtkCellRenderer *cell = GTK_CELL_RENDERER (renderer);
if (number_of_rows == -1)
{
- gint width, height;
+ int width, height;
gtk_cell_renderer_get_fixed_size (cell, &width, &height);
gtk_cell_renderer_set_fixed_size (cell, width, -1);
static void
gtk_cell_renderer_text_get_preferred_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
GtkCellRendererTextPrivate *priv = gtk_cell_renderer_text_get_instance_private (celltext);
PangoContext *context;
PangoFontMetrics *metrics;
PangoRectangle rect;
- gint char_width, text_width, ellipsize_chars, xpad;
- gint min_width, nat_width;
+ int char_width, text_width, ellipsize_chars, xpad;
+ int min_width, nat_width;
/* "width-chars" Hard-coded minimum width:
* - minimum size should be MAX (width-chars, strlen ("..."));
if (priv->max_width_chars > 0)
{
- gint max_width = xpad * 2 + PANGO_PIXELS (char_width) * priv->max_width_chars;
+ int max_width = xpad * 2 + PANGO_PIXELS (char_width) * priv->max_width_chars;
min_width = MIN (min_width, max_width);
nat_width = MIN (nat_width, max_width);
static void
gtk_cell_renderer_text_get_preferred_height_for_width (GtkCellRenderer *cell,
GtkWidget *widget,
- gint width,
- gint *minimum_height,
- gint *natural_height)
+ int width,
+ int *minimum_height,
+ int *natural_height)
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
PangoLayout *layout;
- gint text_height, xpad, ypad;
+ int text_height, xpad, ypad;
gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
static void
gtk_cell_renderer_text_get_preferred_height (GtkCellRenderer *cell,
GtkWidget *widget,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
- gint min_width;
+ int min_width;
/* Thankfully cell renderers dont rotate, so they only have to do
* height-for-width and not the opposite. Here we have only to return
{
GtkCellRendererText *celltext = GTK_CELL_RENDERER_TEXT (cell);
PangoLayout *layout;
- gint x_offset = 0;
- gint y_offset = 0;
+ int x_offset = 0;
+ int y_offset = 0;
layout = get_layout (celltext, widget, cell_area, flags);
get_size (cell, widget, cell_area, layout, &x_offset, &y_offset,
GDK_AVAILABLE_IN_ALL
void gtk_cell_renderer_text_set_fixed_height_from_font (GtkCellRendererText *renderer,
- gint number_of_rows);
+ int number_of_rows);
G_END_DECLS
static void gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height);
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height);
static void gtk_cell_renderer_toggle_snapshot (GtkCellRenderer *cell,
GtkSnapshot *snapshot,
GtkWidget *widget,
gtk_cell_renderer_toggle_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height)
{
- gint calc_width;
- gint calc_height;
- gint xpad, ypad;
+ int calc_width;
+ int calc_height;
+ int xpad, ypad;
GtkStyleContext *context;
GtkBorder border, padding;
GtkCellRendererToggle *celltoggle = GTK_CELL_RENDERER_TOGGLE (cell);
GtkCellRendererTogglePrivate *priv = gtk_cell_renderer_toggle_get_instance_private (celltoggle);
GtkStyleContext *context;
- gint width, height;
- gint x_offset, y_offset;
- gint xpad, ypad;
+ int width, height;
+ int x_offset, y_offset;
+ int xpad, ypad;
GtkStateFlags state;
GtkBorder padding, border;
gtk_snapshot_pop (snapshot);
}
-static gint
+static int
gtk_cell_renderer_toggle_activate (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
{
GtkCellView *cellview = GTK_CELL_VIEW (widget);
GtkCellViewPrivate *priv = gtk_cell_view_get_instance_private (cellview);
- gint alloc_width, alloc_height;
+ int alloc_width, alloc_height;
gtk_cell_area_context_get_allocation (priv->context, &alloc_width, &alloc_height);
gtk_cell_view_request_model (GtkCellView *cellview,
GtkTreeIter *parent,
GtkOrientation orientation,
- gint for_size,
- gint *minimum_size,
- gint *natural_size)
+ int for_size,
+ int *minimum_size,
+ int *natural_size)
{
GtkCellViewPrivate *priv = gtk_cell_view_get_instance_private (cellview);
GtkTreeIter iter;
valid = gtk_tree_model_iter_children (priv->model, &iter, parent);
while (valid)
{
- gint min, nat;
+ int min, nat;
gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
{
if (priv->fit_model)
{
- gint min = 0, nat = 0;
+ int min = 0, nat = 0;
gtk_cell_view_request_model (cellview, NULL, GTK_ORIENTATION_HORIZONTAL, -1, &min, &nat);
}
else
{
if (priv->fit_model)
{
- gint min = 0, nat = 0;
+ int min = 0, nat = 0;
gtk_cell_view_request_model (cellview, NULL, GTK_ORIENTATION_VERTICAL, -1, &min, &nat);
}
else
{
if (priv->fit_model)
{
- gint min = 0, nat = 0;
+ int min = 0, nat = 0;
gtk_cell_view_request_model (cellview, NULL, GTK_ORIENTATION_HORIZONTAL, for_size, &min, &nat);
*minimum = min;
{
if (priv->fit_model)
{
- gint min = 0, nat = 0;
+ int min = 0, nat = 0;
gtk_cell_view_request_model (cellview, NULL, GTK_ORIENTATION_VERTICAL, for_size, &min, &nat);
*minimum = min;
static void
dialog_response (GtkDialog *dialog,
- gint response,
+ int response,
gpointer data)
{
if (response == GTK_RESPONSE_CANCEL)
static void
gtk_color_button_add_palette (GtkColorChooser *chooser,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors)
{
GtkColorButton *button = GTK_COLOR_BUTTON (chooser);
void
gtk_color_chooser_add_palette (GtkColorChooser *chooser,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors)
{
g_return_if_fail (GTK_IS_COLOR_CHOOSER (chooser));
void (* add_palette) (GtkColorChooser *chooser,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors);
/* Signals */
GDK_AVAILABLE_IN_ALL
void gtk_color_chooser_add_palette (GtkColorChooser *chooser,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors);
G_END_DECLS
static void
gtk_color_chooser_dialog_response (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer user_data)
{
if (response_id == GTK_RESPONSE_OK)
static void
gtk_color_chooser_dialog_add_palette (GtkColorChooser *chooser,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors)
{
GtkColorChooserDialog *cc = GTK_COLOR_CHOOSER_DIALOG (chooser);
static void
add_palette (GtkColorChooserWidget *cc,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors,
const gchar **names)
{
GtkWidget *grid;
GtkWidget *p;
AtkObject *atk_obj;
- gint line, pos;
- gint i;
- gint left, right;
+ int line, pos;
+ int i;
+ int left, right;
if (colors == NULL)
{
NC_("Color name", "White")
};
GdkRGBA colors[9*3];
- gint i, j;
+ int i, j;
for (i = 0; i < 9; i++)
for (j = 0; j < 3; j++)
GtkWidget *p;
GtkWidget *button;
GtkWidget *label;
- gint i;
+ int i;
double color[4];
GdkRGBA rgba;
GVariant *variant;
static void
gtk_color_chooser_widget_add_palette (GtkColorChooser *chooser,
GtkOrientation orientation,
- gint colors_per_line,
- gint n_colors,
+ int colors_per_line,
+ int n_colors,
GdkRGBA *colors)
{
GtkColorChooserWidget *cc = GTK_COLOR_CHOOSER_WIDGET (chooser);
GtkWidget *picker_button;
GtkColorPicker *picker;
- gint popup_position;
+ int popup_position;
guint text_changed : 1;
guint use_alpha : 1;
GtkWidget *popup = NULL;
GtkRoot *root;
GtkWidget *focus;
- gint position;
- gint s, e;
+ int position;
+ int s, e;
const char *param;
param = g_variant_get_string (parameters, NULL);
{
GtkRequisition req;
GtkAllocation alloc;
- gint s, e;
+ int s, e;
double x, y;
gtk_widget_get_preferred_size (widget, &req, NULL);
static void
sv_to_xy (GtkColorPlane *plane,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
gdouble s, v;
- gint width, height;
+ int width, height;
width = gtk_widget_get_width (GTK_WIDGET (plane));
height = gtk_widget_get_height (GTK_WIDGET (plane));
GtkSnapshot *snapshot)
{
GtkColorPlane *plane = GTK_COLOR_PLANE (widget);
- gint x, y;
- gint width, height;
+ int x, y;
+ int width, height;
sv_to_xy (plane, &x, &y);
width = gtk_widget_get_width (widget);
{
GtkWidget *widget = GTK_WIDGET (plane);
GBytes *bytes;
- gint width, height, stride;
+ int width, height, stride;
guint red, green, blue;
guint32 *data, *p;
float h, s, v;
float r, g, b;
gdouble sf, vf;
- gint x, y;
+ int x, y;
if (!gtk_widget_get_realized (widget))
return;
static void
update_color (GtkColorPlane *plane,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkWidget *widget = GTK_WIDGET (plane);
gdouble s, v;
if (!priv->hue_texture)
{
GdkTexture *texture;
- gint stride;
+ int stride;
GBytes *bytes;
guchar *data, *p;
gdouble h;
static void
tap_action (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkColorSwatch *swatch)
int *natural_baseline)
{
GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
- gint w, h, min;
+ int w, h, min;
gtk_widget_measure (swatch->overlay_widget,
orientation,
GtkCellArea *area;
- gint active; /* Only temporary */
+ int active; /* Only temporary */
GtkTreeRowReference *active_row;
GtkWidget *cell_view;
/* For "has-entry" specific behavior we track
* an automated cell renderer and text column
*/
- gint text_column;
+ int text_column;
GtkCellRenderer *text_renderer;
- gint id_column;
+ int id_column;
guint popup_in_progress : 1;
guint popup_shown : 1;
static void gtk_combo_box_model_rows_reordered (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer user_data);
static void gtk_combo_box_model_row_changed (GtkTreeModel *model,
GtkTreePath *path,
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
- gint menu_width;
+ int menu_width;
gtk_widget_size_allocate (priv->box,
&(GtkAllocation) {
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
#if 0
- gint active_item;
+ int active_item;
GtkWidget *active;
int width, min_width, nat_width;
#endif
}
else
{
- gint rect_anchor_dy = -2;
+ int rect_anchor_dy = -2;
GList *i;
GtkWidget *child;
if (active)
{
- gint child_height;
+ int child_height;
GList *children;
children = gtk_menu_shell_get_items (GTK_MENU_SHELL (priv->popup_widget));
for (i = children; i && i->data != active; i = i->next)
gtk_combo_box_model_rows_reordered (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer user_data)
{
gtk_tree_row_reference_reordered (G_OBJECT (user_data), path, iter, new_order);
* Returns: An integer which is the index of the currently active item,
* or -1 if there’s no active item.
*/
-gint
+int
gtk_combo_box_get_active (GtkComboBox *combo_box)
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
- gint result;
+ int result;
g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), 0);
*/
void
gtk_combo_box_set_active (GtkComboBox *combo_box,
- gint index_)
+ int index_)
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
GtkTreePath *path = NULL;
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
GtkTreePath *active_path;
- gint path_cmp;
+ int path_cmp;
/* Remember whether the initially active row is valid. */
gboolean is_valid_row_reference = gtk_tree_row_reference_valid (priv->active_row);
*/
void
gtk_combo_box_set_entry_text_column (GtkComboBox *combo_box,
- gint text_column)
+ int text_column)
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
*
* Returns: A column in the data source model of @combo_box.
*/
-gint
+int
gtk_combo_box_get_entry_text_column (GtkComboBox *combo_box)
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
*/
void
gtk_combo_box_set_id_column (GtkComboBox *combo_box,
- gint id_column)
+ int id_column)
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
*
* Returns: A column in the data source model of @combo_box.
*/
-gint
+int
gtk_combo_box_get_id_column (GtkComboBox *combo_box)
{
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
GtkComboBoxPrivate *priv = gtk_combo_box_get_instance_private (combo_box);
GtkTreeModel *model;
GtkTreeIter iter;
- gint column;
+ int column;
g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), NULL);
GtkTreeModel *model;
GtkTreeIter iter;
gboolean match = FALSE;
- gint column;
+ int column;
g_return_val_if_fail (GTK_IS_COMBO_BOX (combo_box), FALSE);
/* get/set active item */
GDK_AVAILABLE_IN_ALL
-gint gtk_combo_box_get_active (GtkComboBox *combo_box);
+int gtk_combo_box_get_active (GtkComboBox *combo_box);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_set_active (GtkComboBox *combo_box,
- gint index_);
+ int index_);
GDK_AVAILABLE_IN_ALL
gboolean gtk_combo_box_get_active_iter (GtkComboBox *combo_box,
GtkTreeIter *iter);
gboolean gtk_combo_box_get_has_entry (GtkComboBox *combo_box);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_set_entry_text_column (GtkComboBox *combo_box,
- gint text_column);
+ int text_column);
GDK_AVAILABLE_IN_ALL
-gint gtk_combo_box_get_entry_text_column (GtkComboBox *combo_box);
+int gtk_combo_box_get_entry_text_column (GtkComboBox *combo_box);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_set_popup_fixed_width (GtkComboBox *combo_box,
AtkObject* gtk_combo_box_get_popup_accessible (GtkComboBox *combo_box);
GDK_AVAILABLE_IN_ALL
-gint gtk_combo_box_get_id_column (GtkComboBox *combo_box);
+int gtk_combo_box_get_id_column (GtkComboBox *combo_box);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_set_id_column (GtkComboBox *combo_box,
- gint id_column);
+ int id_column);
GDK_AVAILABLE_IN_ALL
const gchar * gtk_combo_box_get_active_id (GtkComboBox *combo_box);
GDK_AVAILABLE_IN_ALL
static void
gtk_combo_box_text_constructed (GObject *object)
{
- const gint text_column = 0;
+ const int text_column = 0;
G_OBJECT_CLASS (gtk_combo_box_text_parent_class)->constructed (object);
*/
void
gtk_combo_box_text_insert_text (GtkComboBoxText *combo_box,
- gint position,
+ int position,
const gchar *text)
{
gtk_combo_box_text_insert (combo_box, position, NULL, text);
*/
void
gtk_combo_box_text_insert (GtkComboBoxText *combo_box,
- gint position,
+ int position,
const gchar *id,
const gchar *text)
{
GtkListStore *store;
GtkTreeIter iter;
- gint text_column;
+ int text_column;
g_return_if_fail (GTK_IS_COMBO_BOX_TEXT (combo_box));
g_return_if_fail (text != NULL);
if (id != NULL)
{
- gint id_column;
+ int id_column;
id_column = gtk_combo_box_get_id_column (GTK_COMBO_BOX (combo_box));
g_return_if_fail (id_column >= 0);
*/
void
gtk_combo_box_text_remove (GtkComboBoxText *combo_box,
- gint position)
+ int position)
{
GtkTreeModel *model;
GtkListStore *store;
else if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo_box), &iter))
{
GtkTreeModel *model;
- gint text_column;
+ int text_column;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo_box));
g_return_val_if_fail (GTK_IS_LIST_STORE (model), NULL);
const gchar *text);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_text_insert_text (GtkComboBoxText *combo_box,
- gint position,
+ int position,
const gchar *text);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_text_prepend_text (GtkComboBoxText *combo_box,
const gchar *text);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_text_remove (GtkComboBoxText *combo_box,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_text_remove_all (GtkComboBoxText *combo_box);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_combo_box_text_insert (GtkComboBoxText *combo_box,
- gint position,
+ int position,
const gchar *id,
const gchar *text);
GDK_AVAILABLE_IN_ALL
return compose_list;
}
-static gint
+static int
gtk_compose_data_compare (gpointer a,
gpointer b,
gpointer data)
return contents;
}
-static gint
+static int
gtk_compose_table_find (gconstpointer data1,
gconstpointer data2)
{
GSList *
gtk_compose_table_list_add_array (GSList *compose_tables,
const guint16 *data,
- gint max_seq_len,
- gint n_seqs)
+ int max_seq_len,
+ int n_seqs)
{
guint32 hash;
GtkComposeTable *compose_table;
struct _GtkComposeTable
{
guint16 *data;
- gint max_seq_len;
- gint n_seqs;
+ int max_seq_len;
+ int n_seqs;
guint32 id;
};
struct _GtkComposeTableCompact
{
const guint16 *data;
- gint max_seq_len;
- gint n_index_size;
- gint n_index_stride;
+ int max_seq_len;
+ int n_index_size;
+ int n_index_stride;
};
GtkComposeTable * gtk_compose_table_new_with_file (const gchar *compose_file);
GSList *gtk_compose_table_list_add_array (GSList *compose_tables,
const guint16 *data,
- gint max_seq_len,
- gint n_seqs);
+ int max_seq_len,
+ int n_seqs);
GSList *gtk_compose_table_list_add_file (GSList *compose_tables,
const gchar *compose_file);
gtk_css_animation_get_progress (GtkCssAnimation *animation)
{
gboolean reverse, odd_iteration;
- gint cycle = gtk_progress_tracker_get_iteration_cycle (&animation->tracker);
+ int cycle = gtk_progress_tracker_get_iteration_cycle (&animation->tracker);
odd_iteration = cycle % 2 > 0;
switch (animation->direction)
GtkCssImageIconTheme *icon_theme = GTK_CSS_IMAGE_ICON_THEME (image);
GtkIconPaintable *icon;
double icon_width, icon_height;
- gint size;
+ int size;
double x, y;
size = floor (MIN (width, height));
gtk_css_image_recolor_load (GtkCssImageRecolor *recolor,
GtkCssStyle *style,
GtkCssValue *palette,
- gint scale,
+ int scale,
GError **gerror)
{
GError *local_error = NULL;
GQuark class_quark,
guint *position)
{
- gint min, max, mid;
+ int min, max, mid;
gboolean found = FALSE;
guint pos;
gtk_css_calc_array_add (GPtrArray *array, GtkCssValue *value)
{
gsize i;
- gint calc_term_order;
+ int calc_term_order;
calc_term_order = gtk_css_number_value_get_calc_term_order (value);
gchar *file;
gchar *base;
gchar *subsubdir;
- gint i;
+ int i;
gchar *path;
if (variant)
static gboolean
parse_plus_b (GtkCssParser *parser,
gboolean negate,
- gint *b)
+ int *b)
{
const GtkCssToken *token;
gboolean has_seen_sign;
static gboolean
parse_n_plus_b (GtkCssParser *parser,
- gint before,
- gint *a,
- gint *b)
+ int before,
+ int *a,
+ int *b)
{
const GtkCssToken *token;
static gboolean
parse_a_n_plus_b (GtkCssParser *parser,
- gint seen_sign,
- gint *a,
- gint *b)
+ int seen_sign,
+ int *a,
+ int *b)
{
const GtkCssToken *token;
guint arg,
gpointer data)
{
- gint *ab = data;
+ int *ab = data;
if (!parse_a_n_plus_b (parser, FALSE, &ab[0], &ab[1]))
return 0;
{
if (gtk_css_token_is_function (token, "nth-child"))
{
- gint ab[2];
+ int ab[2];
if (!gtk_css_parser_consume_function (parser, 1, 1, parse_a_n_plus_b_arg, ab))
{
}
else if (gtk_css_token_is_function (token, "nth-last-child"))
{
- gint ab[2];
+ int ab[2];
if (!gtk_css_parser_consume_function (parser, 1, 1, parse_a_n_plus_b_arg, ab))
{
GtkTextDecorationStyle decoration_style;
const GdkRGBA *color;
const GdkRGBA *decoration_color;
- gint letter_spacing;
+ int letter_spacing;
GtkCssFontVariantLigature ligatures;
GtkCssFontVariantNumeric numeric;
GtkCssFontVariantEastAsian east_asian;
/* using define instead of struct here so compilers get the packing right */
#define GTK_CSS_VALUE_BASE \
const GtkCssValueClass *class; \
- gint ref_count; \
+ int ref_count; \
guint is_computed: 1;
struct _GtkCssValueClass {
GKeyFile *keyfile;
gchar *filename, *data, *parentdir;
gsize len;
- gint i = 0;
+ int i = 0;
keyfile = g_key_file_new ();
GtkPageSetup *page_setup;
GtkPaperSize *paper_size;
gchar *name;
- gint i;
+ int i;
i = 1;
name = NULL;
GtkWidget *action_box;
GtkSizeGroup *size_group;
- gint use_header_bar;
+ int use_header_bar;
gboolean constructed;
ResponseData *action_widgets;
} GtkDialogPrivate;
ResponseData *next;
GtkDialog *dialog;
GtkWidget *widget;
- gint response_id;
+ int response_id;
};
static void gtk_dialog_add_buttons_valist (GtkDialog *dialog,
static void
set_use_header_bar (GtkDialog *dialog,
- gint use_header_bar)
+ int use_header_bar)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
static void
action_widget_activated (GtkWidget *widget, GtkDialog *dialog)
{
- gint response_id;
+ int response_id;
response_id = gtk_dialog_get_response_for_widget (dialog, widget);
static void
add_response_data (GtkDialog *dialog,
GtkWidget *child,
- gint response_id)
+ int response_id)
{
ResponseData *ad;
guint signal_id;
static void
add_to_header_bar (GtkDialog *dialog,
GtkWidget *child,
- gint response_id)
+ int response_id)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
static void
apply_response_for_action_area (GtkDialog *dialog,
GtkWidget *child,
- gint response_id)
+ int response_id)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
static void
add_to_action_area (GtkDialog *dialog,
GtkWidget *child,
- gint response_id)
+ int response_id)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
{
gboolean has_default;
ResponseData *rd;
- gint response_id;
+ int response_id;
child = l->data;
void
gtk_dialog_add_action_widget (GtkDialog *dialog,
GtkWidget *child,
- gint response_id)
+ int response_id)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
GtkWidget*
gtk_dialog_add_button (GtkDialog *dialog,
const gchar *button_text,
- gint response_id)
+ int response_id)
{
GtkWidget *button;
va_list args)
{
const gchar* text;
- gint response_id;
+ int response_id;
g_return_if_fail (GTK_IS_DIALOG (dialog));
return;
text = first_button_text;
- response_id = va_arg (args, gint);
+ response_id = va_arg (args, int);
while (text != NULL)
{
**/
void
gtk_dialog_set_response_sensitive (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gboolean setting)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
**/
void
gtk_dialog_set_default_response (GtkDialog *dialog,
- gint response_id)
+ int response_id)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
ResponseData *rd;
**/
void
gtk_dialog_response (GtkDialog *dialog,
- gint response_id)
+ int response_id)
{
g_return_if_fail (GTK_IS_DIALOG (dialog));
*/
GtkWidget*
gtk_dialog_get_widget_for_response (GtkDialog *dialog,
- gint response_id)
+ int response_id)
{
GtkDialogPrivate *priv = gtk_dialog_get_instance_private (dialog);
ResponseData *rd;
* Returns: the response id of @widget, or %GTK_RESPONSE_NONE
* if @widget doesn’t have a response id set.
*/
-gint
+int
gtk_dialog_get_response_for_widget (GtkDialog *dialog,
GtkWidget *widget)
{
typedef struct {
gchar *widget_name;
- gint response_id;
+ int response_id;
gboolean is_default;
- gint line;
- gint col;
+ int line;
+ int col;
} ActionWidgetInfo;
typedef struct {
GtkDialog *dialog;
GtkBuilder *builder;
GSList *items;
- gint response_id;
+ int response_id;
gboolean is_default;
gboolean is_text;
GString *string;
gboolean in_action_widgets;
- gint line;
- gint col;
+ int line;
+ int col;
} SubParserData;
static void
/*< public >*/
- void (* response) (GtkDialog *dialog, gint response_id);
+ void (* response) (GtkDialog *dialog, int response_id);
/* Keybinding signals */
GDK_AVAILABLE_IN_ALL
void gtk_dialog_add_action_widget (GtkDialog *dialog,
GtkWidget *child,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
GtkWidget* gtk_dialog_add_button (GtkDialog *dialog,
const gchar *button_text,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
void gtk_dialog_add_buttons (GtkDialog *dialog,
const gchar *first_button_text,
GDK_AVAILABLE_IN_ALL
void gtk_dialog_set_response_sensitive (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gboolean setting);
GDK_AVAILABLE_IN_ALL
void gtk_dialog_set_default_response (GtkDialog *dialog,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
GtkWidget* gtk_dialog_get_widget_for_response (GtkDialog *dialog,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
-gint gtk_dialog_get_response_for_widget (GtkDialog *dialog,
+int gtk_dialog_get_response_for_widget (GtkDialog *dialog,
GtkWidget *widget);
/* Emit response signal */
GDK_AVAILABLE_IN_ALL
void gtk_dialog_response (GtkDialog *dialog,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
GtkWidget * gtk_dialog_get_content_area (GtkDialog *dialog);
int current_x,
int current_y)
{
- gint drag_threshold;
+ int drag_threshold;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
static void gtk_entry_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot);
static gboolean gtk_entry_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip);
static void gtk_entry_direction_changed (GtkWidget *widget,
GtkEntry *entry = GTK_ENTRY (object);
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
EntryIconInfo *icon_info = NULL;
- gint i;
+ int i;
for (i = 0; i < MAX_ICONS; i++)
{
static void
icon_pressed_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkEntry *entry)
static void
icon_released_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkEntry *entry)
const gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
- gint i;
+ int i;
GtkAllocation text_alloc;
text_alloc.x = 0;
**/
void
gtk_entry_set_max_length (GtkEntry *entry,
- gint max)
+ int max)
{
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
* Returns: the maximum allowed number of characters
* in #GtkEntry, or 0 if there is no maximum.
**/
-gint
+int
gtk_entry_get_max_length (GtkEntry *entry)
{
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
*
* Returns: the index of the icon at the given position, or -1
*/
-gint
+int
gtk_entry_get_icon_at_pos (GtkEntry *entry,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
guint i;
* Returns: index of the icon which is the source of the current
* DND operation, or -1.
*/
-gint
+int
gtk_entry_get_current_icon_drag_source (GtkEntry *entry)
{
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
EntryIconInfo *icon_info = NULL;
- gint i;
+ int i;
g_return_val_if_fail (GTK_IS_ENTRY (entry), -1);
static gboolean
gtk_entry_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip)
{
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
EntryIconInfo *icon_info;
- gint icon_pos;
+ int icon_pos;
if (!keyboard_tip)
{
/* text is truncated if needed */
GDK_AVAILABLE_IN_ALL
void gtk_entry_set_max_length (GtkEntry *entry,
- gint max);
+ int max);
GDK_AVAILABLE_IN_ALL
-gint gtk_entry_get_max_length (GtkEntry *entry);
+int gtk_entry_get_max_length (GtkEntry *entry);
GDK_AVAILABLE_IN_ALL
guint16 gtk_entry_get_text_length (GtkEntry *entry);
gboolean gtk_entry_get_icon_sensitive (GtkEntry *entry,
GtkEntryIconPosition icon_pos);
GDK_AVAILABLE_IN_ALL
-gint gtk_entry_get_icon_at_pos (GtkEntry *entry,
- gint x,
- gint y);
+int gtk_entry_get_icon_at_pos (GtkEntry *entry,
+ int x,
+ int y);
GDK_AVAILABLE_IN_ALL
void gtk_entry_set_icon_tooltip_text (GtkEntry *entry,
GtkEntryIconPosition icon_pos,
GdkContentProvider *provider,
GdkDragAction actions);
GDK_AVAILABLE_IN_ALL
-gint gtk_entry_get_current_icon_drag_source (GtkEntry *entry);
+int gtk_entry_get_current_icon_drag_source (GtkEntry *entry);
GDK_AVAILABLE_IN_ALL
void gtk_entry_get_icon_area (GtkEntry *entry,
GtkEntryIconPosition icon_pos,
gsize normal_text_bytes;
guint normal_text_chars;
- gint max_length;
+ int max_length;
};
G_DEFINE_TYPE_WITH_PRIVATE (GtkEntryBuffer, gtk_entry_buffer, G_TYPE_OBJECT)
**/
GtkEntryBuffer*
gtk_entry_buffer_new (const gchar *initial_chars,
- gint n_initial_chars)
+ int n_initial_chars)
{
GtkEntryBuffer *buffer = g_object_new (GTK_TYPE_ENTRY_BUFFER, NULL);
if (initial_chars)
void
gtk_entry_buffer_set_text (GtkEntryBuffer *buffer,
const gchar *chars,
- gint n_chars)
+ int n_chars)
{
g_return_if_fail (GTK_IS_ENTRY_BUFFER (buffer));
g_return_if_fail (chars != NULL);
**/
void
gtk_entry_buffer_set_max_length (GtkEntryBuffer *buffer,
- gint max_length)
+ int max_length)
{
GtkEntryBufferPrivate *priv = gtk_entry_buffer_get_instance_private (buffer);
* Returns: the maximum allowed number of characters
* in #GtkEntryBuffer, or 0 if there is no maximum.
*/
-gint
+int
gtk_entry_buffer_get_max_length (GtkEntryBuffer *buffer)
{
GtkEntryBufferPrivate *priv = gtk_entry_buffer_get_instance_private (buffer);
gtk_entry_buffer_insert_text (GtkEntryBuffer *buffer,
guint position,
const gchar *chars,
- gint n_chars)
+ int n_chars)
{
GtkEntryBufferPrivate *pv = gtk_entry_buffer_get_instance_private (buffer);
GtkEntryBufferClass *klass;
guint
gtk_entry_buffer_delete_text (GtkEntryBuffer *buffer,
guint position,
- gint n_chars)
+ int n_chars)
{
GtkEntryBufferClass *klass;
guint length;
GDK_AVAILABLE_IN_ALL
GtkEntryBuffer* gtk_entry_buffer_new (const gchar *initial_chars,
- gint n_initial_chars);
+ int n_initial_chars);
GDK_AVAILABLE_IN_ALL
gsize gtk_entry_buffer_get_bytes (GtkEntryBuffer *buffer);
GDK_AVAILABLE_IN_ALL
void gtk_entry_buffer_set_text (GtkEntryBuffer *buffer,
const gchar *chars,
- gint n_chars);
+ int n_chars);
GDK_AVAILABLE_IN_ALL
void gtk_entry_buffer_set_max_length (GtkEntryBuffer *buffer,
- gint max_length);
+ int max_length);
GDK_AVAILABLE_IN_ALL
-gint gtk_entry_buffer_get_max_length (GtkEntryBuffer *buffer);
+int gtk_entry_buffer_get_max_length (GtkEntryBuffer *buffer);
GDK_AVAILABLE_IN_ALL
guint gtk_entry_buffer_insert_text (GtkEntryBuffer *buffer,
guint position,
const gchar *chars,
- gint n_chars);
+ int n_chars);
GDK_AVAILABLE_IN_ALL
guint gtk_entry_buffer_delete_text (GtkEntryBuffer *buffer,
guint position,
- gint n_chars);
+ int n_chars);
GDK_AVAILABLE_IN_ALL
void gtk_entry_buffer_emit_inserted_text (GtkEntryBuffer *buffer,
*/
void
gtk_entry_completion_set_minimum_key_length (GtkEntryCompletion *completion,
- gint length)
+ int length)
{
g_return_if_fail (GTK_IS_ENTRY_COMPLETION (completion));
g_return_if_fail (length >= 0);
*
* Returns: The currently used minimum key length
*/
-gint
+int
gtk_entry_completion_get_minimum_key_length (GtkEntryCompletion *completion)
{
g_return_val_if_fail (GTK_IS_ENTRY_COMPLETION (completion), 0);
*/
void
gtk_entry_completion_set_text_column (GtkEntryCompletion *completion,
- gint column)
+ int column)
{
GtkCellRenderer *cell;
*
* Returns: the column containing the strings
*/
-gint
+int
gtk_entry_completion_get_text_column (GtkEntryCompletion *completion)
{
g_return_val_if_fail (GTK_IS_ENTRY_COMPLETION (completion), -1);
_gtk_entry_completion_resize_popup (GtkEntryCompletion *completion)
{
GtkAllocation allocation;
- gint matches, items, height;
+ int matches, items, height;
GdkSurface *surface;
GtkRequisition entry_req;
GtkRequisition tree_req;
GtkTreePath *path;
- gint width;
+ int width;
surface = gtk_native_get_surface (gtk_widget_get_native (completion->entry));
{
if (prefix)
{
- gint key_len;
- gint prefix_len;
+ int key_len;
+ int prefix_len;
const gchar *key;
prefix_len = g_utf8_strlen (prefix, -1);
if (prefix_len > key_len)
{
- gint pos = prefix_len;
+ int pos = prefix_len;
gtk_editable_insert_text (GTK_EDITABLE (completion->entry),
prefix + strlen (key), -1, &pos);
gtk_entry_completion_insert_completion_text (GtkEntryCompletion *completion,
const gchar *new_text)
{
- gint len;
+ int len;
GtkText *text = gtk_entry_get_text_widget (GTK_ENTRY (completion->entry));
GtkEntryBuffer *buffer = gtk_text_get_buffer (text);
}
-static gint
+static int
gtk_entry_completion_timeout (gpointer data)
{
GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (data);
g_utf8_strlen (gtk_editable_get_text (GTK_EDITABLE (completion->entry)), -1)
>= completion->minimum_key_length)
{
- gint matches;
+ int matches;
gboolean popup_single;
gtk_entry_completion_complete (completion);
GdkModifierType state,
gpointer user_data)
{
- gint matches;
+ int matches;
GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);
GtkWidget *widget = completion->entry;
GtkText *text = gtk_entry_get_text_widget (GTK_ENTRY (widget));
GDestroyNotify func_notify);
GDK_AVAILABLE_IN_ALL
void gtk_entry_completion_set_minimum_key_length (GtkEntryCompletion *completion,
- gint length);
+ int length);
GDK_AVAILABLE_IN_ALL
-gint gtk_entry_completion_get_minimum_key_length (GtkEntryCompletion *completion);
+int gtk_entry_completion_get_minimum_key_length (GtkEntryCompletion *completion);
GDK_AVAILABLE_IN_ALL
gchar * gtk_entry_completion_compute_prefix (GtkEntryCompletion *completion,
const char *key);
/* convenience */
GDK_AVAILABLE_IN_ALL
void gtk_entry_completion_set_text_column (GtkEntryCompletion *completion,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
-gint gtk_entry_completion_get_text_column (GtkEntryCompletion *completion);
+int gtk_entry_completion_get_text_column (GtkEntryCompletion *completion);
G_END_DECLS
gpointer match_data;
GDestroyNotify match_notify;
- gint minimum_key_length;
- gint text_column;
+ int minimum_key_length;
+ int text_column;
gchar *case_normalized_key;
gulong changed_id;
gulong insert_text_id;
- gint current_selected;
+ int current_selected;
guint first_sel_changed : 1;
guint has_completion : 1;
GtkTreeModel *model,
GtkTreeIter *iter);
void (* action_activated) (GtkEntryCompletion *completion,
- gint index_);
+ int index_);
gboolean (* insert_prefix) (GtkEntryCompletion *completion,
const gchar *prefix);
gboolean (* cursor_on_match) (GtkEntryCompletion *completion,
if (scroll->flags & GTK_EVENT_CONTROLLER_SCROLL_DISCRETE)
{
- gint steps;
+ int steps;
scroll->cur_dx += dx;
scroll->cur_dy += dy;
/* Gestures */
static void gesture_click_released_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkExpander *expander);
static void
gesture_click_released_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkExpander *expander)
return changed;
}
-static gint
+static int
param_expression_values_cmp (GParamSpec *pspec,
const GValue *value1,
const GValue *value2)
GFile *file,
GtkTreeIter *iter);
-static gint model_get_type_position (GtkFileChooserButton *button,
+static int model_get_type_position (GtkFileChooserButton *button,
RowType row_type);
static void model_free_row_data (GtkFileChooserButton *button,
GtkTreeIter *iter);
static void model_update_current_folder (GtkFileChooserButton *button,
GFile *file);
static void model_remove_rows (GtkFileChooserButton *button,
- gint pos,
- gint n_rows);
+ int pos,
+ int n_rows);
static gboolean filter_model_visible_func (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data);
static void dialog_response_cb (GtkDialog *dialog,
- gint response,
+ int response,
gpointer user_data);
static void native_response_cb (GtkFileChooserNative *native,
- gint response,
+ int response,
gpointer user_data);
static void volumes_changed (GVolumeMonitor *volume_monitor,
gpointer volume,
{
GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (chooser);
GtkTreeIter iter;
- gint pos;
+ int pos;
pos = model_get_type_position (button, ROW_TYPE_SHORTCUT);
pos += button->n_shortcuts;
{
GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (chooser);
GtkTreeIter iter;
- gint pos;
+ int pos;
gchar type;
pos = model_get_type_position (button, ROW_TYPE_SHORTCUT);
icon = _gtk_file_info_get_icon (info, ICON_SIZE, gtk_widget_get_scale_factor (GTK_WIDGET (data->button)));
if (icon)
{
- gint width = 0;
+ int width = 0;
GtkTreeIter iter;
GtkTreePath *path;
change_icon_theme (GtkFileChooserButton *button)
{
GtkTreeIter iter;
- gint width = 0;
+ int width = 0;
g_slist_free_full (button->change_icon_theme_cancellables, (GDestroyNotify)g_cancellable_cancel);
button->change_icon_theme_cancellables = NULL;
}
/* Shortcuts Model */
-static gint
+static int
model_get_type_position (GtkFileChooserButton *button,
RowType row_type)
{
- gint retval = 0;
+ int retval = 0;
if (row_type == ROW_TYPE_SPECIAL)
return retval;
GtkListStore *store;
GtkTreeIter iter;
GFile *file;
- gint pos;
+ int pos;
store = GTK_LIST_STORE (button->model);
pos = model_get_type_position (button, ROW_TYPE_SPECIAL);
GSList *volumes)
{
GtkListStore *store;
- gint pos;
+ int pos;
GSList *l;
if (!volumes)
{
GtkListStore *store;
GtkTreeIter iter;
- gint pos;
+ int pos;
GSList *l;
if (!bookmarks)
{
GtkListStore *store;
GtkTreeIter iter;
- gint pos;
+ int pos;
if (!file)
return;
{
GtkListStore *store;
GtkTreeIter iter;
- gint pos;
+ int pos;
GIcon *icon;
store = GTK_LIST_STORE (button->model);
static void
model_remove_rows (GtkFileChooserButton *button,
- gint pos,
- gint n_rows)
+ int pos,
+ int n_rows)
{
GtkListStore *store;
if (!row_found)
{
- gint pos;
+ int pos;
/* If it hasn't been found already, update & select the current-folder row. */
if (file)
static void
common_response_cb (GtkFileChooserButton *button,
- gint response)
+ int response)
{
if (response == GTK_RESPONSE_ACCEPT ||
response == GTK_RESPONSE_OK)
static void
dialog_response_cb (GtkDialog *dialog,
- gint response,
+ int response,
gpointer user_data)
{
GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
static void
native_response_cb (GtkFileChooserNative *native,
- gint response,
+ int response,
gpointer user_data)
{
GtkFileChooserButton *button = GTK_FILE_CHOOSER_BUTTON (user_data);
*
* Returns: an integer width (in characters) that the button will use to size itself.
*/
-gint
+int
gtk_file_chooser_button_get_width_chars (GtkFileChooserButton *button)
{
g_return_val_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button), -1);
*/
void
gtk_file_chooser_button_set_width_chars (GtkFileChooserButton *button,
- gint n_chars)
+ int n_chars)
{
g_return_if_fail (GTK_IS_FILE_CHOOSER_BUTTON (button));
void gtk_file_chooser_button_set_title (GtkFileChooserButton *button,
const gchar *title);
GDK_AVAILABLE_IN_ALL
-gint gtk_file_chooser_button_get_width_chars (GtkFileChooserButton *button);
+int gtk_file_chooser_button_get_width_chars (GtkFileChooserButton *button);
GDK_AVAILABLE_IN_ALL
void gtk_file_chooser_button_set_width_chars (GtkFileChooserButton *button,
- gint n_chars);
+ int n_chars);
GDK_AVAILABLE_IN_ALL
gboolean gtk_file_chooser_button_get_modal (GtkFileChooserButton *button);
GDK_AVAILABLE_IN_ALL
GVariant *parameters);
static void response_cb (GtkDialog *dialog,
- gint response_id);
+ int response_id);
static void setup_save_entry (GtkFileChooserDialog *dialog);
get_accept_action_widget (GtkDialog *dialog,
gboolean sensitive_only)
{
- gint response[] = {
+ int response[] = {
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_OK,
GTK_RESPONSE_YES,
GTK_RESPONSE_APPLY
};
- gint i;
+ int i;
GtkWidget *widget;
for (i = 0; i < G_N_ELEMENTS (response); i++)
}
static gboolean
-is_accept_response_id (gint response_id)
+is_accept_response_id (int response_id)
{
return (response_id == GTK_RESPONSE_ACCEPT ||
response_id == GTK_RESPONSE_OK ||
{
GtkFileChooserDialog *dialog = GTK_FILE_CHOOSER_DIALOG (widget);
GSettings *settings;
- gint width, height;
+ int width, height;
settings = _gtk_file_chooser_get_settings_for_widget (widget);
g_settings_get (settings, SETTINGS_KEY_WINDOW_SIZE, "(ii)", &width, &height);
*/
static void
response_cb (GtkDialog *dialog,
- gint response_id)
+ int response_id)
{
GtkFileChooserDialogPrivate *priv = gtk_file_chooser_dialog_get_instance_private (GTK_FILE_CHOOSER_DIALOG (dialog));
{
GtkWidget *result;
const char *button_text = first_button_text;
- gint response_id;
+ int response_id;
result = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"title", title,
while (button_text)
{
- response_id = va_arg (varargs, gint);
+ response_id = va_arg (varargs, int);
gtk_dialog_add_button (GTK_DIALOG (result), button_text, response_id);
button_text = va_arg (varargs, const gchar *);
}
GtkFileChooserEntry *chooser_entry);
#ifdef G_OS_WIN32
-static gint insert_text_callback (GtkFileChooserEntry *widget,
+static int insert_text_callback (GtkFileChooserEntry *widget,
const gchar *new_text,
- gint new_text_length,
- gint *position,
+ int new_text_length,
+ int *position,
gpointer user_data);
static void delete_text_callback (GtkFileChooserEntry *widget,
- gint start_pos,
- gint end_pos,
+ int start_pos,
+ int end_pos,
gpointer user_data);
#endif
GtkFileChooserEntry *chooser_entry)
{
char *path;
- gint pos;
+ int pos;
gtk_tree_model_get (model, iter,
FULL_PATH_COLUMN, &path,
GtkFileChooserEntry *chooser_entry)
{
GtkEditable *editable = GTK_EDITABLE (chooser_entry);
- gint start, end;
+ int start, end;
if (keyval == GDK_KEY_Escape &&
chooser_entry->eat_escape)
}
#ifdef G_OS_WIN32
-static gint
+static int
insert_text_callback (GtkFileChooserEntry *chooser_entry,
const gchar *new_text,
- gint new_text_length,
- gint *position,
+ int new_text_length,
+ int *position,
gpointer user_data)
{
const gchar *colon = memchr (new_text, ':', new_text_length);
- gint i;
+ int i;
/* Disallow these characters altogether */
for (i = 0; i < new_text_length; i++)
static void
delete_text_callback (GtkFileChooserEntry *chooser_entry,
- gint start_pos,
- gint end_pos,
+ int start_pos,
+ int end_pos,
gpointer user_data)
{
/* If deleting a drive letter, delete the colon, too */
len = g_utf8_pointer_to_offset (str, ext);
}
- gtk_editable_select_region (GTK_EDITABLE (chooser_entry), 0, (gint) len);
+ gtk_editable_select_region (GTK_EDITABLE (chooser_entry), 0, (int) len);
}
void
static void
dialog_response_cb (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer data)
{
GtkFileChooserNative *self = data;
if (!data->save)
{
NSArray *urls;
- gint i;
+ int i;
urls = [(NSOpenPanel *)data->panel URLs];
for (l = self->choices; l; l = l->next)
{
GtkFileChooserNativeChoice *choice = (GtkFileChooserNativeChoice*) l->data;
- gint sel = g_array_index (data->choices_selections, gint,
+ int sel = g_array_index (data->choices_selections, int,
g_slist_position (self->choices, l));
if (sel >= 0)
if (data->choices_selections)
g_array_free (data->choices_selections, TRUE);
- data->choices_selections = g_array_sized_new (FALSE, FALSE, sizeof(gint),
+ data->choices_selections = g_array_sized_new (FALSE, FALSE, sizeof(int),
g_slist_length (data->self->choices));
hr = IFileDialog_QueryInterface (pfd, &IID_IFileDialogCustomize, (LPVOID *) &pfdc);
{
GtkFileChooserNativeChoice *choice = (GtkFileChooserNativeChoice*) l->data;
DWORD dialog_item_id = (DWORD) g_slist_position (data->self->choices, l);
- gint val = -1;
+ int val = -1;
if (choice->options)
{
dialog_item_id,
&dialog_sub_item_id);
if (SUCCEEDED (hr))
- val = (gint) dialog_sub_item_id;
+ val = (int) dialog_sub_item_id;
}
else
{
GtkWidget *toplevel_current_focus_widget;
GtkWidget *toplevel_last_focus_widget;
- gint sort_column;
+ int sort_column;
GtkSortType sort_order;
ClockFormat clock_format;
static void home_folder_handler (GtkFileChooserWidget *impl);
static void desktop_folder_handler (GtkFileChooserWidget *impl);
static void quick_bookmark_handler (GtkFileChooserWidget *impl,
- gint bookmark_index);
+ int bookmark_index);
static void show_hidden_handler (GtkFileChooserWidget *impl);
static void search_shortcut_handler (GtkFileChooserWidget *impl);
static void recent_shortcut_handler (GtkFileChooserWidget *impl);
gboolean remove_from_treeview);
static gboolean recent_should_respond (GtkFileChooserWidget *impl);
static void clear_model_cache (GtkFileChooserWidget *impl,
- gint column);
+ int column);
static void set_model_filter (GtkFileChooserWidget *impl,
GtkFileFilter *filter);
static void switch_to_home_dir (GtkFileChooserWidget *impl);
/* Checks whether the selected items in the file list are all files or all folders */
static void
selection_check (GtkFileChooserWidget *impl,
- gint *num_selected,
+ int *num_selected,
gboolean *all_files,
gboolean *all_folders)
{
static void
clear_model_cache (GtkFileChooserWidget *impl,
- gint column)
+ int column)
{
if (impl->browse_files_model)
_gtk_file_system_model_clear_cache (impl->browse_files_model, column);
static void
check_file_list_popover_sensitivity (GtkFileChooserWidget *impl)
{
- gint num_selected;
+ int num_selected;
gboolean all_files;
gboolean all_folders;
gboolean active;
typedef struct {
OperationMode operation_mode;
- gint general_column;
- gint model_column;
+ int general_column;
+ int model_column;
} ColumnMap;
/* Sets the sort column IDs for the file list; needs to be done whenever we
static gboolean
file_list_query_tooltip_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer user_data)
static void
set_icon_cell_renderer_fixed_size (GtkFileChooserWidget *impl)
{
- gint xpad, ypad;
+ int xpad, ypad;
gtk_cell_renderer_get_padding (impl->list_pixbuf_renderer, &xpad, &ypad);
gtk_cell_renderer_set_fixed_size (impl->list_pixbuf_renderer,
get_accept_action_widget (GtkDialog *dialog,
gboolean sensitive_only)
{
- gint response[] = {
+ int response[] = {
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_OK,
GTK_RESPONSE_YES,
GTK_RESPONSE_APPLY
};
- gint i;
+ int i;
GtkWidget *widget;
for (i = 0; i < G_N_ELEMENTS (response); i++)
gboolean sort_directories_first;
DateFormat date_format;
TypeFormat type_format;
- gint sort_column;
+ int sort_column;
GtkSortType sort_order;
StartupMode startup_mode;
- gint sidebar_width;
+ int sidebar_width;
GSettings *settings;
settings = _gtk_file_chooser_get_settings_for_widget (GTK_WIDGET (impl));
GTK_WIDGET_CLASS (gtk_file_chooser_widget_parent_class)->unmap (widget);
}
-static gint
+static int
compare_directory (GtkFileSystemModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
return 0;
}
-static gint
+static int
compare_name (GtkFileSystemModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
GtkFileChooserWidget *impl)
{
const char *key_a, *key_b;
- gint result;
+ int result;
key_a = g_value_get_string (_gtk_file_system_model_get_value (model, a, MODEL_COL_NAME_COLLATED));
key_b = g_value_get_string (_gtk_file_system_model_get_value (model, b, MODEL_COL_NAME_COLLATED));
return result;
}
-static gint
+static int
compare_size (GtkFileSystemModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
return size_a < size_b ? -1 : (size_a == size_b ? 0 : 1);
}
-static gint
+static int
compare_type (GtkFileSystemModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
return g_strcmp0 (key_a, key_b);
}
-static gint
+static int
compare_time (GtkFileSystemModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
return ta < tb ? -1 : (ta == tb ? 0 : 1);
}
-static gint
+static int
compare_location (GtkFileSystemModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
}
/* Sort callback for the filename column */
-static gint
+static int
name_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);
GtkFileChooserWidget *impl = user_data;
- gint result;
+ int result;
result = compare_directory (fs_model, a, b, impl);
}
/* Sort callback for the size column */
-static gint
+static int
size_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);
GtkFileChooserWidget *impl = user_data;
- gint result;
+ int result;
result = compare_directory (fs_model, a, b, impl);
}
/* Sort callback for the type column */
-static gint
+static int
type_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);
GtkFileChooserWidget *impl = user_data;
- gint result;
+ int result;
result = compare_directory (fs_model, a, b, impl);
}
/* Sort callback for the time column */
-static gint
+static int
time_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);
GtkFileChooserWidget *impl = user_data;
- gint result;
+ int result;
result = compare_directory (fs_model, a, b, impl);
return result;
}
-static gint
+static int
recent_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);
GtkFileChooserWidget *impl = user_data;
- gint result;
+ int result;
result = compare_time (fs_model, a, b, impl);
return result;
}
-static gint
+static int
search_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
{
GtkFileSystemModel *fs_model = GTK_FILE_SYSTEM_MODEL (model);
GtkFileChooserWidget *impl = user_data;
- gint result;
+ int result;
result = compare_location (fs_model, a, b, impl);
list_sort_column_changed_cb (GtkTreeSortable *sortable,
GtkFileChooserWidget *impl)
{
- gint sort_column_id;
+ int sort_column_id;
GtkSortType sort_type;
if (gtk_tree_sortable_get_sort_column_id (sortable, &sort_column_id, &sort_type))
GDateTime *now_date, *date;
const gchar *format;
gchar *date_str;
- gint days_ago;
+ int days_ago;
time = g_date_time_new_from_unix_local (secs);
date = g_date_time_new_local (g_date_time_get_year (time),
GtkTreeIter first_selected_iter;
};
-static gint
+static int
compare_utf8_filenames (const gchar *a,
const gchar *b)
{
gchar *a_folded, *b_folded;
- gint retval;
+ int retval;
a_folded = g_utf8_strdown (a, -1);
b_folded = g_utf8_strdown (b, -1);
static void
add_custom_button_to_dialog (GtkDialog *dialog,
const gchar *mnemonic_label,
- gint response_id)
+ int response_id)
{
GtkWidget *button;
static void
quick_bookmark_handler (GtkFileChooserWidget *impl,
- gint bookmark_index)
+ int bookmark_index)
{
GFile *file;
};
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
- gint i;
+ int i;
gobject_class->finalize = gtk_file_chooser_widget_finalize;
gobject_class->constructed = gtk_file_chooser_widget_constructed;
return GTK_TREE_MODEL_LIST_ONLY;
}
-static gint
+static int
gtk_file_system_model_get_n_columns (GtkTreeModel *tree_model)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
static GType
gtk_file_system_model_get_column_type (GtkTreeModel *tree_model,
- gint i)
+ int i)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
gtk_file_system_model_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
char *node;
static void
gtk_file_system_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (tree_model);
return FALSE;
}
-static gint
+static int
gtk_file_system_model_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
static gboolean
gtk_file_system_model_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
static void
gtk_file_system_model_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order)
{
GtkFileSystemModel *model = GTK_FILE_SYSTEM_MODEL (sortable);
static void
gtk_file_system_model_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
static void
gtk_file_system_model_set_n_columns (GtkFileSystemModel *model,
- gint n_columns,
+ int n_columns,
va_list args)
{
guint i;
GtkFlowBoxChild *child);
static void gtk_flow_box_apply_sort (GtkFlowBox *box,
GtkFlowBoxChild *child);
-static gint gtk_flow_box_sort (GtkFlowBoxChild *a,
+static int gtk_flow_box_sort (GtkFlowBoxChild *a,
GtkFlowBoxChild *b,
GtkFlowBox *box);
static void
path_from_horizontal_line_rects (cairo_t *cr,
GdkRectangle *lines,
- gint n_lines)
+ int n_lines)
{
- gint start_line, end_line;
+ int start_line, end_line;
GdkRectangle *r;
- gint i;
+ int i;
/* Join rows vertically by extending to the middle */
for (i = 0; i < n_lines - 1; i++)
{
GdkRectangle *r1 = &lines[i];
GdkRectangle *r2 = &lines[i+1];
- gint gap, old;
+ int gap, old;
gap = r2->y - (r1->y + r1->height);
r1->height += gap / 2;
static void
path_from_vertical_line_rects (cairo_t *cr,
GdkRectangle *lines,
- gint n_lines)
+ int n_lines)
{
- gint start_line, end_line;
+ int start_line, end_line;
GdkRectangle *r;
- gint i;
+ int i;
/* Join rows horizontally by extending to the middle */
for (i = 0; i < n_lines - 1; i++)
{
GdkRectangle *r1 = &lines[i];
GdkRectangle *r2 = &lines[i+1];
- gint gap, old;
+ int gap, old;
gap = r2->x - (r1->x + r1->width);
r1->width += gap / 2;
* Returns: the index of the @child, or -1 if the @child is not
* in a flow box.
*/
-gint
+int
gtk_flow_box_child_get_index (GtkFlowBoxChild *child)
{
GtkFlowBoxChildPrivate *priv;
void (*toggle_cursor_child) (GtkFlowBox *box);
gboolean (*move_cursor) (GtkFlowBox *box,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
void (*select_all) (GtkFlowBox *box);
gtk_widget_get_child_visible (child);
}
-static gint
+static int
get_visible_children (GtkFlowBox *box)
{
GSequenceIter *iter;
- gint i = 0;
+ int i = 0;
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
!g_sequence_iter_is_end (iter);
GSequenceIter *iter)
{
GtkFlowBoxChild *child = NULL;
- gint i;
+ int i;
while (TRUE)
{
GSequenceIter *iter)
{
GtkFlowBoxChild *child = NULL;
- gint i;
+ int i;
while (TRUE)
{
static void
get_max_item_size (GtkFlowBox *box,
GtkOrientation orientation,
- gint *min_size,
- gint *nat_size)
+ int *min_size,
+ int *nat_size)
{
GSequenceIter *iter;
- gint max_min_size = 0;
- gint max_nat_size = 0;
+ int max_min_size = 0;
+ int max_nat_size = 0;
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
!g_sequence_iter_is_end (iter);
iter = g_sequence_iter_next (iter))
{
GtkWidget *child;
- gint child_min, child_nat;
+ int child_min, child_nat;
child = g_sequence_get (iter);
static void
get_largest_size_for_opposing_orientation (GtkFlowBox *box,
GtkOrientation orientation,
- gint item_size,
- gint *min_item_size,
- gint *nat_item_size)
+ int item_size,
+ int *min_item_size,
+ int *nat_item_size)
{
GSequenceIter *iter;
- gint max_min_size = 0;
- gint max_nat_size = 0;
+ int max_min_size = 0;
+ int max_nat_size = 0;
for (iter = g_sequence_get_begin_iter (BOX_PRIV (box)->children);
!g_sequence_iter_is_end (iter);
iter = g_sequence_iter_next (iter))
{
GtkWidget *child;
- gint child_min, child_nat;
+ int child_min, child_nat;
child = g_sequence_get (iter);
get_largest_size_for_line_in_opposing_orientation (GtkFlowBox *box,
GtkOrientation orientation,
GSequenceIter *cursor,
- gint line_length,
+ int line_length,
GtkRequestedSize *item_sizes,
- gint extra_pixels,
- gint *min_item_size,
- gint *nat_item_size)
+ int extra_pixels,
+ int *min_item_size,
+ int *nat_item_size)
{
GSequenceIter *iter;
- gint max_min_size = 0;
- gint max_nat_size = 0;
- gint i;
+ int max_min_size = 0;
+ int max_nat_size = 0;
+ int i;
i = 0;
for (iter = cursor;
iter = g_sequence_iter_next (iter))
{
GtkWidget *child;
- gint child_min, child_nat, this_item_size;
+ int child_min, child_nat, this_item_size;
child = g_sequence_get (iter);
}
/* fit_aligned_item_requests() helper */
-static gint
+static int
gather_aligned_item_requests (GtkFlowBox *box,
GtkOrientation orientation,
- gint line_length,
- gint item_spacing,
- gint n_children,
+ int line_length,
+ int item_spacing,
+ int n_children,
GtkRequestedSize *item_sizes)
{
GSequenceIter *iter;
- gint i;
- gint extra_items, natural_line_size = 0;
+ int i;
+ int extra_items, natural_line_size = 0;
extra_items = n_children % line_length;
{
GtkWidget *child;
GtkAlign item_align;
- gint child_min, child_nat;
- gint position;
+ int child_min, child_nat;
+ int position;
child = g_sequence_get (iter);
static GtkRequestedSize *
fit_aligned_item_requests (GtkFlowBox *box,
GtkOrientation orientation,
- gint avail_size,
- gint item_spacing,
- gint *line_length, /* in-out */
- gint items_per_line,
- gint n_children)
+ int avail_size,
+ int item_spacing,
+ int *line_length, /* in-out */
+ int items_per_line,
+ int n_children)
{
GtkRequestedSize *sizes, *try_sizes;
- gint try_line_size, try_length;
+ int try_line_size, try_length;
sizes = g_new0 (GtkRequestedSize, *line_length);
typedef struct {
GArray *requested;
- gint extra_pixels;
+ int extra_pixels;
} AllocatedLine;
-static gint
+static int
get_offset_pixels (GtkAlign align,
- gint pixels)
+ int pixels)
{
- gint offset;
+ int offset;
switch (align) {
case GTK_ALIGN_START:
GtkFlowBox *box = GTK_FLOW_BOX (widget);
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
GtkAllocation child_allocation;
- gint avail_size, avail_other_size, min_items, item_spacing, line_spacing;
+ int avail_size, avail_other_size, min_items, item_spacing, line_spacing;
GtkAlign item_align;
GtkAlign line_align;
GtkRequestedSize *line_sizes = NULL;
GtkRequestedSize *item_sizes = NULL;
- gint min_item_size, nat_item_size;
- gint line_length;
- gint item_size = 0;
- gint line_size = 0, min_fixed_line_size = 0, nat_fixed_line_size = 0;
- gint line_offset, item_offset, n_children, n_lines, line_count;
- gint extra_pixels = 0, extra_per_item = 0, extra_extra = 0;
- gint extra_line_pixels = 0, extra_per_line = 0, extra_line_extra = 0;
- gint i, this_line_size;
+ int min_item_size, nat_item_size;
+ int line_length;
+ int item_size = 0;
+ int line_size = 0, min_fixed_line_size = 0, nat_fixed_line_size = 0;
+ int line_offset, item_offset, n_children, n_lines, line_count;
+ int extra_pixels = 0, extra_per_item = 0, extra_extra = 0;
+ int extra_line_pixels = 0, extra_per_line = 0, extra_line_extra = 0;
+ int i, this_line_size;
GSequenceIter *iter;
min_items = MAX (1, priv->min_children_per_line);
iter = g_sequence_iter_next (iter))
{
GtkWidget *child;
- gint position;
- gint this_item_size;
+ int position;
+ int this_item_size;
child = g_sequence_get (iter);
* any leading items */
if (line_count == n_lines -1)
{
- gint extra_items = n_children % line_length;
+ int extra_items = n_children % line_length;
if (priv->homogeneous)
{
}
else
{
- gint j;
+ int j;
for (j = 0; j < (line_length - extra_items); j++)
{
/* Push the index along for the last line when spreading to the end */
if (item_align == GTK_ALIGN_END && line_count == n_lines -1)
{
- gint extra_items = n_children % line_length;
+ int extra_items = n_children % line_length;
position += line_length - extra_items;
}
static void
get_largest_aligned_line_length (GtkFlowBox *box,
GtkOrientation orientation,
- gint line_length,
- gint *min_size,
- gint *nat_size)
+ int line_length,
+ int *min_size,
+ int *nat_size)
{
GSequenceIter *iter;
- gint max_min_size = 0;
- gint max_nat_size = 0;
- gint spacing, i;
+ int max_min_size = 0;
+ int max_nat_size = 0;
+ int spacing, i;
GtkRequestedSize *aligned_item_sizes;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
iter = g_sequence_iter_next (iter))
{
GtkWidget *child;
- gint child_min, child_nat;
+ int child_min, child_nat;
child = g_sequence_get (iter);
if (!child_is_visible (child))
{
if (for_size < 0)
{
- gint min_item_width, nat_item_width;
- gint min_items, nat_items;
- gint min_width, nat_width;
+ int min_item_width, nat_item_width;
+ int min_items, nat_items;
+ int min_width, nat_width;
min_items = MAX (1, priv->min_children_per_line);
nat_items = MAX (min_items, priv->max_children_per_line);
}
else
{
- gint min_line_length, nat_line_length;
+ int min_line_length, nat_line_length;
get_largest_aligned_line_length (box,
GTK_ORIENTATION_HORIZONTAL,
else /* GTK_ORIENTATION_VERTICAL */
{
/* Return the width for the minimum height */
- gint min_height;
+ int min_height;
int dummy;
gtk_flow_box_measure (widget,
}
else
{
- gint min_item_height, nat_item_height;
- gint min_items;
- gint min_width, nat_width;
- gint avail_size, n_children;
+ int min_item_height, nat_item_height;
+ int min_items;
+ int min_width, nat_width;
+ int avail_size, n_children;
min_items = MAX (1, priv->min_children_per_line);
}
else /* GTK_ORIENTATION_VERTICAL */
{
- gint min_height;
- gint line_length;
- gint item_size, extra_pixels;
+ int min_height;
+ int line_length;
+ int item_size, extra_pixels;
int dummy;
n_children = get_visible_children (box);
if (priv->homogeneous)
{
- gint min_item_width, nat_item_width;
- gint lines;
+ int min_item_width, nat_item_width;
+ int lines;
/* Here we just use the largest height-for-width and
* add up the size accordingly
}
else
{
- gint min_line_width, nat_line_width, i;
+ int min_line_width, nat_line_width, i;
gboolean first_line = TRUE;
GtkRequestedSize *item_sizes;
GSequenceIter *iter;
{
if (for_size < 0)
{
- gint min_item_height, nat_item_height;
- gint min_items, nat_items;
- gint min_height, nat_height;
+ int min_item_height, nat_item_height;
+ int min_items, nat_items;
+ int min_height, nat_height;
min_items = MAX (1, priv->min_children_per_line);
nat_items = MAX (min_items, priv->max_children_per_line);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
/* Return the height for the minimum width */
- gint min_width;
+ int min_width;
int dummy;
gtk_flow_box_measure (widget,
}
else
{
- gint min_line_length, nat_line_length;
+ int min_line_length, nat_line_length;
get_largest_aligned_line_length (box,
GTK_ORIENTATION_VERTICAL,
}
else
{
- gint min_item_width, nat_item_width;
- gint min_items;
- gint min_height, nat_height;
- gint avail_size, n_children;
+ int min_item_width, nat_item_width;
+ int min_items;
+ int min_height, nat_height;
+ int avail_size, n_children;
min_items = MAX (1, priv->min_children_per_line);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
- gint min_width;
- gint line_length;
- gint item_size, extra_pixels;
+ int min_width;
+ int line_length;
+ int item_size, extra_pixels;
int dummy;
n_children = get_visible_children (box);
if (priv->homogeneous)
{
- gint min_item_height, nat_item_height;
- gint lines;
+ int min_item_height, nat_item_height;
+ int lines;
/* Here we just use the largest height-for-width and
* add up the size accordingly
}
else
{
- gint min_line_height, nat_line_height, i;
+ int min_line_height, nat_line_height, i;
gboolean first_line = TRUE;
GtkRequestedSize *item_sizes;
GSequenceIter *iter;
static void
update_autoscroll_mode (GtkFlowBox *box,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
GtkScrollType mode = GTK_SCROLL_NONE;
GdkRectangle rect;
- gint size, pos;
+ int size, pos;
if (priv->rubberband_select && get_view_rect (box, &rect))
{
guint keyval,
GdkModifierType modmask,
GtkMovementStep step,
- gint count)
+ int count)
{
gtk_widget_class_add_binding_signal (widget_class,
keyval, modmask,
static gboolean
gtk_flow_box_move_cursor (GtkFlowBox *box,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify)
{
GtkFlowBoxChild *prev;
GtkFlowBoxChild *next;
GtkAllocation allocation;
- gint page_size;
+ int page_size;
GSequenceIter *iter;
- gint start;
+ int start;
GtkAdjustment *adjustment;
gboolean vertical;
if (count < 0)
{
- gint i = 0;
+ int i = 0;
/* Up */
while (iter != NULL)
}
else
{
- gint i = 0;
+ int i = 0;
/* Down */
while (!g_sequence_iter_is_end (iter))
{
GtkFlowBox *box = user_data;
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
- gint i;
+ int i;
while (removed--)
{
void
gtk_flow_box_insert (GtkFlowBox *box,
GtkWidget *widget,
- gint position)
+ int position)
{
GtkFlowBoxPrivate *priv;
GtkFlowBoxChild *child;
*/
GtkFlowBoxChild *
gtk_flow_box_get_child_at_index (GtkFlowBox *box,
- gint idx)
+ int idx)
{
GSequenceIter *iter;
*/
GtkFlowBoxChild *
gtk_flow_box_get_child_at_pos (GtkFlowBox *box,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkWidget *child = gtk_widget_pick (GTK_WIDGET (box), x, y, GTK_PICK_DEFAULT);
gtk_flow_box_invalidate_sort (box);
}
-static gint
+static int
gtk_flow_box_sort (GtkFlowBoxChild *a,
GtkFlowBoxChild *b,
GtkFlowBox *box)
GtkWidget * gtk_flow_box_child_get_child (GtkFlowBoxChild *self);
GDK_AVAILABLE_IN_ALL
-gint gtk_flow_box_child_get_index (GtkFlowBoxChild *child);
+int gtk_flow_box_child_get_index (GtkFlowBoxChild *child);
GDK_AVAILABLE_IN_ALL
gboolean gtk_flow_box_child_is_selected (GtkFlowBoxChild *child);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_flow_box_insert (GtkFlowBox *box,
GtkWidget *widget,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_flow_box_remove (GtkFlowBox *box,
GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
GtkFlowBoxChild *gtk_flow_box_get_child_at_index (GtkFlowBox *box,
- gint idx);
+ int idx);
GDK_AVAILABLE_IN_ALL
GtkFlowBoxChild *gtk_flow_box_get_child_at_pos (GtkFlowBox *box,
- gint x,
- gint y);
+ int x,
+ int y);
typedef void (* GtkFlowBoxForeachFunc) (GtkFlowBox *box,
GtkFlowBoxChild *child,
GDK_AVAILABLE_IN_ALL
void gtk_flow_box_invalidate_filter (GtkFlowBox *box);
-typedef gint (*GtkFlowBoxSortFunc) (GtkFlowBoxChild *child1,
- GtkFlowBoxChild *child2,
- gpointer user_data);
+typedef int (*GtkFlowBoxSortFunc) (GtkFlowBoxChild *child1,
+ GtkFlowBoxChild *child2,
+ gpointer user_data);
GDK_AVAILABLE_IN_ALL
void gtk_flow_box_set_sort_func (GtkFlowBox *box,
PangoFontFamily *font_family;
PangoFontFace *font_face;
PangoFontMap *font_map;
- gint font_size;
+ int font_size;
char *font_features;
PangoLanguage *language;
gchar *preview_text;
/* Dialog response functions */
static void response_cb (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer data);
static void dialog_destroy (GtkWidget *widget,
gpointer data);
{
PangoFontFamily **families;
PangoFontFace **faces;
- gint n_families, n_faces, i;
+ int n_families, n_faces, i;
const gchar *family;
g_assert (font_button->font_desc != NULL);
static void
response_cb (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer data)
{
GtkFontButton *font_button = GTK_FONT_BUTTON (data);
* Returns: A n integer representing the selected font size,
* or -1 if no font size is selected.
*/
-gint
+int
gtk_font_chooser_get_font_size (GtkFontChooser *fontchooser)
{
g_return_val_if_fail (GTK_IS_FONT_CHOOSER (fontchooser), -1);
/* Methods */
PangoFontFamily * (* get_font_family) (GtkFontChooser *fontchooser);
PangoFontFace * (* get_font_face) (GtkFontChooser *fontchooser);
- gint (* get_font_size) (GtkFontChooser *fontchooser);
+ int (* get_font_size) (GtkFontChooser *fontchooser);
void (* set_filter_func) (GtkFontChooser *fontchooser,
GtkFontFilterFunc filter,
GDK_AVAILABLE_IN_ALL
PangoFontFace *gtk_font_chooser_get_font_face (GtkFontChooser *fontchooser);
GDK_AVAILABLE_IN_ALL
-gint gtk_font_chooser_get_font_size (GtkFontChooser *fontchooser);
+int gtk_font_chooser_get_font_size (GtkFontChooser *fontchooser);
GDK_AVAILABLE_IN_ALL
PangoFontDescription *
{
GtkAdjustment *adj, *spin_adj;
const int *sizes;
- gint *font_sizes;
- gint i, n_sizes;
+ int *font_sizes;
+ int i, n_sizes;
gdouble value, spin_value;
gpointer item;
if (n_sizes < 2)
{
- static const gint fallback_sizes[] = {
+ static const int fallback_sizes[] = {
6, 8, 9, 10, 11, 12, 13, 14, 16, 20, 24, 36, 48, 72
};
return pango_font_face_get_family (item);
}
-static gint
+static int
gtk_font_chooser_widget_get_size (GtkFontChooser *chooser)
{
GtkFontChooserWidget *fontchooser = GTK_FONT_CHOOSER_WIDGET (chooser);
hb_tag_t *lang_tag,
hb_tag_t *script_tag)
{
- gint i, j, k;
+ int i, j, k;
hb_tag_t scripts[80];
unsigned int n_scripts;
unsigned int count;
const gchar *type);
static void gtk_frame_measure (GtkWidget *widget,
GtkOrientation orientation,
- gint for_size,
- gint *minimum_size,
- gint *natural_size,
- gint *minimum_baseline,
- gint *natural_baseline);
+ int for_size,
+ int *minimum_size,
+ int *natural_size,
+ int *minimum_baseline,
+ int *natural_baseline);
static void gtk_frame_compute_expand (GtkWidget *widget,
gboolean *hexpand,
gboolean *vexpand);
{
GtkFramePrivate *priv = gtk_frame_get_instance_private (frame);
int frame_width, frame_height;
- gint height;
+ int height;
frame_width = gtk_widget_get_width (GTK_WIDGET (frame));
frame_height = gtk_widget_get_height (GTK_WIDGET (frame));
if (priv->label_widget)
{
- gint nat_width, width;
+ int nat_width, width;
gtk_widget_measure (priv->label_widget, GTK_ORIENTATION_HORIZONTAL, -1,
NULL, &nat_width, NULL, NULL);
static void
gtk_frame_measure (GtkWidget *widget,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkFrame *frame = GTK_FRAME (widget);
GtkFramePrivate *priv = gtk_frame_get_instance_private (frame);
GtkGestureSingleClass parent_class;
void (* pressed) (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y);
void (* released) (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y);
void (* stopped) (GtkGestureClick *gesture);
GdkEvent *event;
GdkEventType event_type;
GtkWidget *widget;
- gint delay;
+ int delay;
priv = gtk_gesture_long_press_get_instance_private (GTK_GESTURE_LONG_PRESS (gesture));
sequence = gtk_gesture_single_get_current_sequence (GTK_GESTURE_SINGLE (gesture));
"gtk-long-press-time", &delay,
NULL);
- delay = (gint)(priv->delay_factor * delay);
+ delay = (int)(priv->delay_factor * delay);
gtk_gesture_get_point (gesture, sequence,
&priv->initial_x, &priv->initial_y);
{
GdkEvent *event;
GArray *array;
- gint i = 0;
+ int i = 0;
g_return_val_if_fail (GTK_IS_GESTURE_STYLUS (gesture), FALSE);
g_return_val_if_fail (values != NULL, FALSE);
guint32 evtime)
{
GtkGestureSwipePrivate *priv;
- gint i, length = 0;
+ int i, length = 0;
priv = gtk_gesture_swipe_get_instance_private (gesture);
- for (i = 0; i < (gint) priv->events->len; i++)
+ for (i = 0; i < (int) priv->events->len; i++)
{
EventData *data;
static void
gtk_gl_area_draw_error_screen (GtkGLArea *area,
GtkSnapshot *snapshot,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkGLAreaPrivate *priv = gtk_gl_area_get_instance_private (area);
PangoLayout *layout;
*/
void
gtk_gl_area_set_required_version (GtkGLArea *area,
- gint major,
- gint minor)
+ int major,
+ int minor)
{
GtkGLAreaPrivate *priv = gtk_gl_area_get_instance_private (area);
*/
void
gtk_gl_area_get_required_version (GtkGLArea *area,
- gint *major,
- gint *minor)
+ int *major,
+ int *minor)
{
GtkGLAreaPrivate *priv = gtk_gl_area_get_instance_private (area);
gboolean gtk_gl_area_get_use_es (GtkGLArea *area);
GDK_AVAILABLE_IN_ALL
void gtk_gl_area_set_required_version (GtkGLArea *area,
- gint major,
- gint minor);
+ int major,
+ int minor);
GDK_AVAILABLE_IN_ALL
void gtk_gl_area_get_required_version (GtkGLArea *area,
- gint *major,
- gint *minor);
+ int *major,
+ int *minor);
GDK_AVAILABLE_IN_ALL
gboolean gtk_gl_area_get_has_depth_buffer (GtkGLArea *area);
GDK_AVAILABLE_IN_ALL
static void
grid_attach (GtkGrid *grid,
GtkWidget *widget,
- gint left,
- gint top,
- gint width,
- gint height)
+ int left,
+ int top,
+ int width,
+ int height)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkGridLayoutChild *grid_child;
* @op_pos, @op_span determine the rows/columns
* in which the touching has to happen.
*/
-static gint
+static int
find_attach_position (GtkGrid *grid,
GtkOrientation orientation,
- gint op_pos,
- gint op_span,
+ int op_pos,
+ int op_span,
gboolean max)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkWidget *child;
gboolean hit;
- gint pos;
+ int pos;
if (max)
pos = -G_MAXINT;
void
gtk_grid_attach (GtkGrid *grid,
GtkWidget *child,
- gint left,
- gint top,
- gint width,
- gint height)
+ int left,
+ int top,
+ int width,
+ int height)
{
g_return_if_fail (GTK_IS_GRID (grid));
g_return_if_fail (GTK_IS_WIDGET (child));
GtkWidget *child,
GtkWidget *sibling,
GtkPositionType side,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkGridLayoutChild *grid_sibling;
- gint left, top;
+ int left, top;
g_return_if_fail (GTK_IS_GRID (grid));
g_return_if_fail (GTK_IS_WIDGET (child));
*/
GtkWidget *
gtk_grid_get_child_at (GtkGrid *grid,
- gint left,
- gint top)
+ int left,
+ int top)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkWidget *child;
*/
void
gtk_grid_insert_row (GtkGrid *grid,
- gint position)
+ int position)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkWidget *child;
*/
void
gtk_grid_remove_row (GtkGrid *grid,
- gint position)
+ int position)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkWidget *child;
*/
void
gtk_grid_insert_column (GtkGrid *grid,
- gint position)
+ int position)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkWidget *child;
*/
void
gtk_grid_remove_column (GtkGrid *grid,
- gint position)
+ int position)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkWidget *child;
*/
void
gtk_grid_set_row_baseline_position (GtkGrid *grid,
- gint row,
+ int row,
GtkBaselinePosition pos)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
*/
GtkBaselinePosition
gtk_grid_get_row_baseline_position (GtkGrid *grid,
- gint row)
+ int row)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
*/
void
gtk_grid_set_baseline_row (GtkGrid *grid,
- gint row)
+ int row)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
int old_row;
*
* Returns: the row index defining the global baseline
*/
-gint
+int
gtk_grid_get_baseline_row (GtkGrid *grid)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
void
gtk_grid_query_child (GtkGrid *grid,
GtkWidget *child,
- gint *left,
- gint *top,
- gint *width,
- gint *height)
+ int *left,
+ int *top,
+ int *width,
+ int *height)
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
GtkGridLayoutChild *grid_child;
GDK_AVAILABLE_IN_ALL
void gtk_grid_attach (GtkGrid *grid,
GtkWidget *child,
- gint left,
- gint top,
- gint width,
- gint height);
+ int left,
+ int top,
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_grid_attach_next_to (GtkGrid *grid,
GtkWidget *child,
GtkWidget *sibling,
GtkPositionType side,
- gint width,
- gint height);
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
GtkWidget *gtk_grid_get_child_at (GtkGrid *grid,
- gint left,
- gint top);
+ int left,
+ int top);
GDK_AVAILABLE_IN_ALL
void gtk_grid_remove (GtkGrid *grid,
GtkWidget *child);
GDK_AVAILABLE_IN_ALL
void gtk_grid_insert_row (GtkGrid *grid,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_grid_insert_column (GtkGrid *grid,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_grid_remove_row (GtkGrid *grid,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_grid_remove_column (GtkGrid *grid,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_grid_insert_next_to (GtkGrid *grid,
GtkWidget *sibling,
guint gtk_grid_get_column_spacing (GtkGrid *grid);
GDK_AVAILABLE_IN_ALL
void gtk_grid_set_row_baseline_position (GtkGrid *grid,
- gint row,
+ int row,
GtkBaselinePosition pos);
GDK_AVAILABLE_IN_ALL
GtkBaselinePosition gtk_grid_get_row_baseline_position (GtkGrid *grid,
- gint row);
+ int row);
GDK_AVAILABLE_IN_ALL
void gtk_grid_set_baseline_row (GtkGrid *grid,
- gint row);
+ int row);
GDK_AVAILABLE_IN_ALL
-gint gtk_grid_get_baseline_row (GtkGrid *grid);
+int gtk_grid_get_baseline_row (GtkGrid *grid);
GDK_AVAILABLE_IN_ALL
void gtk_grid_query_child (GtkGrid *grid,
GtkWidget *child,
- gint *left,
- gint *top,
- gint *width,
- gint *height);
+ int *left,
+ int *top,
+ int *width,
+ int *height);
G_END_DECLS
/* Sums allocations for lines spanned by child and their spacing.
*/
-static gint
+static int
compute_allocation_for_child (GridRequest *request,
GtkGridLayoutChild *child,
GtkOrientation orientation)
GtkGridLayout *self = request->layout;
GridLineData *linedata;
GridLines *lines;
- gint minimum, natural;
- gint i;
+ int minimum, natural;
+ int i;
linedata = &self->linedata[orientation];
lines = &request->lines[orientation];
{
GridRequest request;
GridLines *lines;
- gint min_size, nat_size;
+ int min_size, nat_size;
*minimum = 0;
*natural = 0;
{
GtkWidget *child;
GtkAllocation child_allocation;
- gint x, y, width, height, baseline, ignore;
+ int x, y, width, height, baseline, ignore;
for (child = gtk_widget_get_first_child (request->widget);
#define GET_UINT32(cache, offset) (GUINT32_FROM_BE (*(guint32 *)((cache) + (offset))))
struct _GtkIconCache {
- gint ref_count;
+ int ref_count;
GMappedFile *map;
gchar *buffer;
return cache;
}
-static gint
+static int
get_directory_index (GtkIconCache *cache,
const gchar *directory)
{
guint32 dir_list_offset;
- gint n_dirs;
- gint i;
+ int n_dirs;
+ int i;
dir_list_offset = GET_UINT32 (cache->buffer, 8);
const gchar *directory,
GtkStringSet *set)
{
- gint directory_index;
+ int directory_index;
guint32 hash_offset, n_buckets;
guint32 chain_offset;
guint32 image_list_offset, n_images;
const gchar *cache;
gsize cache_size;
guint32 n_directories;
- gint flags;
+ int flags;
} CacheInfo;
gboolean gtk_icon_cache_validate (CacheInfo *info);
GtkImageDefinition *def;
- gint pixel_size;
+ int pixel_size;
guint use_fallback : 1;
guint texture_is_symbolic : 1;
ensure_paintable_for_gicon (GtkIconHelper *self,
GtkCssStyle *style,
GtkTextDirection dir,
- gint scale,
+ int scale,
gboolean preload,
GIcon *gicon,
gboolean *symbolic)
{
GtkIconTheme *icon_theme;
- gint width, height;
+ int width, height;
GtkIconPaintable *icon;
GtkIconLookupFlags flags;
gboolean
_gtk_icon_helper_set_pixel_size (GtkIconHelper *self,
- gint pixel_size)
+ int pixel_size)
{
if (self->pixel_size != pixel_size)
{
return self->use_fallback;
}
-gint
+int
_gtk_icon_helper_get_pixel_size (GtkIconHelper *self)
{
return self->pixel_size;
GdkPaintable *paintable);
gboolean _gtk_icon_helper_set_pixel_size (GtkIconHelper *self,
- gint pixel_size);
+ int pixel_size);
gboolean _gtk_icon_helper_set_use_fallback (GtkIconHelper *self,
gboolean use_fallback);
GtkImageType _gtk_icon_helper_get_storage_type (GtkIconHelper *self);
-gint _gtk_icon_helper_get_pixel_size (GtkIconHelper *self);
+int _gtk_icon_helper_get_pixel_size (GtkIconHelper *self);
gboolean _gtk_icon_helper_get_use_fallback (GtkIconHelper *self);
GIcon *_gtk_icon_helper_peek_gicon (GtkIconHelper *self);
typedef struct {
gchar **icon_names;
- gint size;
- gint scale;
+ int size;
+ int scale;
GtkIconLookupFlags flags;
} IconKey;
/* Parameters influencing the scaled icon
*/
- gint desired_size;
- gint desired_scale;
+ int desired_size;
+ int desired_scale;
guint is_svg : 1;
guint is_resource : 1;
guint is_symbolic : 1;
typedef struct
{
IconThemeDirType type;
- gint size;
- gint min_size;
- gint max_size;
- gint threshold;
- gint scale;
+ int size;
+ int min_size;
+ int max_size;
+ int threshold;
+ int scale;
GArray *icon_files;
GHashTable *icon_hash; /* name (interned) -> file index */
static void theme_destroy (IconTheme *theme);
static GtkIconPaintable *theme_lookup_icon (IconTheme *theme,
const gchar *icon_name,
- gint size,
- gint scale,
+ int size,
+ int scale,
gboolean allow_svg);
static gboolean theme_has_icon (IconTheme *theme,
const gchar *icon_name);
{
GSList *formats;
GSList *tmp_list;
- static gint found_svg = -1;
+ static int found_svg = -1;
if (found_svg != -1)
return found_svg;
insert_theme (GtkIconTheme *self,
const gchar *theme_name)
{
- gint i;
+ int i;
GList *l;
gchar **dirs;
gchar **scaled_dirs;
load_themes (GtkIconTheme *self)
{
GDir *gdir;
- gint base;
+ int base;
gchar *dir;
const gchar *file;
GTimeVal tv;
for (j = 0; self->resource_path[j]; j++)
{
gchar **children;
- gint i;
+ int i;
dir = self->resource_path[j];
children = g_resources_enumerate_children (dir, 0, NULL);
static GtkIconPaintable *
real_choose_icon (GtkIconTheme *self,
const gchar *icon_names[],
- gint size,
- gint scale,
+ int size,
+ int scale,
GtkIconLookupFlags flags,
gboolean non_blocking)
{
UnthemedIcon *unthemed_icon = NULL;
const gchar *icon_name = NULL;
IconTheme *theme = NULL;
- gint i;
+ int i;
IconKey key;
if (!ensure_valid_themes (self, non_blocking))
static GtkIconPaintable *
choose_icon (GtkIconTheme *self,
const gchar *icon_names[],
- gint size,
- gint scale,
+ int size,
+ int scale,
GtkTextDirection direction,
GtkIconLookupFlags flags,
gboolean non_blocking)
gtk_icon_theme_lookup_icon (GtkIconTheme *self,
const char *icon_name,
const char *fallbacks[],
- gint size,
- gint scale,
+ int size,
+ int scale,
GtkTextDirection direction,
GtkIconLookupFlags flags)
{
gpointer value,
gpointer user_data)
{
- gint **res_p = user_data;
+ int **res_p = user_data;
**res_p = GPOINTER_TO_INT (key);
* available. The array should be freed with g_free() when it is no
* longer needed.
*/
-gint *
+int *
gtk_icon_theme_get_icon_sizes (GtkIconTheme *self,
const gchar *icon_name)
{
GList *l;
int i;
GHashTable *sizes;
- gint *result, *r;
+ int *result, *r;
g_return_val_if_fail (GTK_IS_ICON_THEME (self), NULL);
}
}
- r = result = g_new0 (gint, g_hash_table_size (sizes) + 1);
+ r = result = g_new0 (int, g_hash_table_size (sizes) + 1);
g_hash_table_foreach (sizes, add_size, &r);
g_hash_table_destroy (sizes);
static gboolean
rescan_themes (GtkIconTheme *self)
{
- gint stat_res;
+ int stat_res;
GStatBuf stat_buf;
GTimeVal tv;
guint i;
static int
theme_dir_size_difference (IconThemeDirSize *dir_size,
- gint size,
- gint scale)
+ int size,
+ int scale)
{
- gint scaled_size, scaled_dir_size;
- gint min, max;
+ int scaled_size, scaled_dir_size;
+ int min, max;
scaled_size = size * scale;
scaled_dir_size = dir_size->size * dir_size->scale;
/* returns TRUE if dir_a is a better match */
static gboolean
-compare_dir_size_matches (IconThemeDirSize *dir_a, gint difference_a,
- IconThemeDirSize *dir_b, gint difference_b,
- gint requested_size,
- gint requested_scale)
+compare_dir_size_matches (IconThemeDirSize *dir_a, int difference_a,
+ IconThemeDirSize *dir_b, int difference_b,
+ int requested_size,
+ int requested_scale)
{
- gint diff_a;
- gint diff_b;
+ int diff_a;
+ int diff_b;
if (difference_a == 0)
{
static GtkIconPaintable *
theme_lookup_icon (IconTheme *theme,
const gchar *icon_name, /* interned */
- gint size,
- gint scale,
+ int size,
+ int scale,
gboolean allow_svg)
{
IconThemeDirSize *min_dir_size;
IconThemeFile *min_file;
- gint min_difference;
+ int min_difference;
IconCacheFlag min_suffix;
int i;
IconThemeDirSize *dir_size = &g_array_index (theme->dir_sizes, IconThemeDirSize, i);
IconThemeFile *file;
guint best_suffix;
- gint difference;
+ int difference;
gpointer file_index;
if (!g_hash_table_lookup_extended (dir_size->icon_hash, icon_name, NULL, &file_index))
static guint32
theme_ensure_dir_size (IconTheme *theme,
IconThemeDirType type,
- gint size,
- gint min_size,
- gint max_size,
- gint threshold,
- gint scale)
+ int size,
+ int min_size,
+ int max_size,
+ int threshold,
+ int scale)
{
guint32 index;
IconThemeDirSize new = { 0 };
{
gchar *type_string;
IconThemeDirType type;
- gint size;
- gint min_size;
- gint max_size;
- gint threshold;
+ int size;
+ int min_size;
+ int max_size;
+ int threshold;
GError *error = NULL;
guint32 dir_size_index;
IconThemeDirSize *dir_size;
- gint scale;
+ int scale;
guint i;
size = g_key_file_get_integer (theme_file, subdir, "Size", &error);
{
GdkPixbuf *source_pixbuf;
gint64 before;
- gint pixel_size;
+ int pixel_size;
GError *load_error = NULL;
icon_cache_mark_used_if_cached (icon);
*/
GtkIconPaintable *
gtk_icon_paintable_new_for_file (GFile *file,
- gint size,
- gint scale)
+ int size,
+ int scale)
{
GtkIconPaintable *icon;
int scale)
{
GtkIconPaintable *icon;
- gint width, height;
+ int width, height;
if (size <= 0)
{
GtkIconPaintable *
gtk_icon_theme_lookup_by_gicon (GtkIconTheme *self,
GIcon *gicon,
- gint size,
- gint scale,
+ int size,
+ int scale,
GtkTextDirection direction,
GtkIconLookupFlags flags)
{
gboolean gtk_icon_theme_has_icon (GtkIconTheme *self,
const gchar *icon_name);
GDK_AVAILABLE_IN_ALL
-gint *gtk_icon_theme_get_icon_sizes (GtkIconTheme *self,
+int *gtk_icon_theme_get_icon_sizes (GtkIconTheme *self,
const gchar *icon_name);
GDK_AVAILABLE_IN_ALL
GtkIconPaintable *gtk_icon_theme_lookup_icon (GtkIconTheme *self,
const char *icon_name,
const char *fallbacks[],
- gint size,
- gint scale,
+ int size,
+ int scale,
GtkTextDirection direction,
GtkIconLookupFlags flags);
GDK_AVAILABLE_IN_ALL
GtkIconPaintable *gtk_icon_theme_lookup_by_gicon (GtkIconTheme *self,
GIcon *icon,
- gint size,
- gint scale,
+ int size,
+ int scale,
GtkTextDirection direction,
GtkIconLookupFlags flags);
GDK_AVAILABLE_IN_ALL
GtkIconPaintable *gtk_icon_paintable_new_for_file (GFile *file,
- gint size,
- gint scale);
+ int size,
+ int scale);
GDK_AVAILABLE_IN_ALL
char ** gtk_icon_theme_get_icon_names (GtkIconTheme *self);
static void gtk_icon_view_snapshot_item (GtkIconView *icon_view,
GtkSnapshot *snapshot,
GtkIconViewItem *item,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean draw_focus);
static void gtk_icon_view_snapshot_rubberband (GtkIconView *icon_view,
GtkSnapshot *snapshot);
GtkIconViewItem *item);
static void gtk_icon_view_start_rubberbanding (GtkIconView *icon_view,
GdkDevice *device,
- gint x,
- gint y);
+ int x,
+ int y);
static void gtk_icon_view_stop_rubberbanding (GtkIconView *icon_view);
static void gtk_icon_view_update_rubberband_selection (GtkIconView *icon_view);
static gboolean gtk_icon_view_item_hit_test (GtkIconView *icon_view,
GtkIconViewItem *item,
- gint x,
- gint y,
- gint width,
- gint height);
+ int x,
+ int y,
+ int width,
+ int height);
static gboolean gtk_icon_view_unselect_all_internal (GtkIconView *icon_view);
static void gtk_icon_view_update_rubberband (GtkIconView *icon_view);
static void gtk_icon_view_item_invalidate_size (GtkIconViewItem *item);
guint keyval,
guint modmask,
GtkMovementStep step,
- gint count);
+ int count);
static gboolean gtk_icon_view_real_move_cursor (GtkIconView *icon_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
static void gtk_icon_view_move_cursor_up_down (GtkIconView *icon_view,
- gint count);
+ int count);
static void gtk_icon_view_move_cursor_page_up_down (GtkIconView *icon_view,
- gint count);
+ int count);
static void gtk_icon_view_move_cursor_left_right (GtkIconView *icon_view,
- gint count);
+ int count);
static void gtk_icon_view_move_cursor_start_end (GtkIconView *icon_view,
- gint count);
+ int count);
static void gtk_icon_view_scroll_to_item (GtkIconView *icon_view,
GtkIconViewItem *item);
static gboolean gtk_icon_view_select_all_between (GtkIconView *icon_view,
/* GtkWidget methods */
-static gint
+static int
gtk_icon_view_get_n_items (GtkIconView *icon_view)
{
GtkIconViewPrivate *priv = icon_view->priv;
{
if (icon_view->priv->text_cell)
{
- gint pixbuf_width, wrap_width;
+ int pixbuf_width, wrap_width;
if (icon_view->priv->items && icon_view->priv->pixbuf_cell)
{
cell_area_get_preferred_size (GtkIconView *icon_view,
GtkCellAreaContext *context,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural)
+ int for_size,
+ int *minimum,
+ int *natural)
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
static void
gtk_icon_view_get_preferred_item_size (GtkIconView *icon_view,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural)
+ int for_size,
+ int *minimum,
+ int *natural)
{
GtkIconViewPrivate *priv = icon_view->priv;
GtkCellAreaContext *context;
static void
gtk_icon_view_compute_n_items_for_size (GtkIconView *icon_view,
GtkOrientation orientation,
- gint size,
- gint *min_items,
- gint *min_item_size,
- gint *max_items,
- gint *max_item_size)
+ int size,
+ int *min_items,
+ int *min_item_size,
+ int *max_items,
+ int *max_item_size)
{
GtkIconViewPrivate *priv = icon_view->priv;
int minimum, natural, spacing;
GtkIconView *icon_view;
GList *icons;
GtkTreePath *path;
- gint dest_index;
+ int dest_index;
GtkIconViewDropPosition dest_pos;
GtkIconViewItem *dest_item = NULL;
GtkStyleContext *context;
static GtkIconViewItem *
_gtk_icon_view_get_item_at_widget_coords (GtkIconView *icon_view,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean only_in_cell,
GtkCellRenderer **cell_at_pos)
{
gpointer user_data)
{
GtkIconView *icon_view;
- gint abs_y;
+ int abs_y;
GdkDevice *device;
icon_view = GTK_ICON_VIEW (user_data);
static void
gtk_icon_view_update_rubberband (GtkIconView *icon_view)
{
- gint x, y;
+ int x, y;
x = MAX (icon_view->priv->mouse_x, 0);
y = MAX (icon_view->priv->mouse_y, 0);
static void
gtk_icon_view_start_rubberbanding (GtkIconView *icon_view,
GdkDevice *device,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkIconViewPrivate *priv = icon_view->priv;
GList *items;
gtk_icon_view_update_rubberband_selection (GtkIconView *icon_view)
{
GList *items;
- gint x, y, width, height;
+ int x, y, width, height;
gboolean dirty = FALSE;
x = MIN (icon_view->priv->rubberband_x1,
static gboolean
gtk_icon_view_item_hit_test (GtkIconView *icon_view,
GtkIconViewItem *item,
- gint x,
- gint y,
- gint width,
- gint height)
+ int x,
+ int y,
+ int width,
+ int height)
{
HitTestData data = { { x, y, width, height }, FALSE };
GtkCellAreaContext *context;
gtk_widget_queue_draw (GTK_WIDGET (icon_view));
}
-static gint
+static int
compare_sizes (gconstpointer p1,
gconstpointer p2,
gpointer unused)
GtkIconViewPrivate *priv = icon_view->priv;
GtkWidget *widget = GTK_WIDGET (icon_view);
GList *items;
- gint item_width = 0; /* this doesn't include item_padding */
- gint n_columns, n_rows, n_items;
- gint col, row;
+ int item_width = 0; /* this doesn't include item_padding */
+ int n_columns, n_rows, n_items;
+ int col, row;
GtkRequestedSize *sizes;
gboolean rtl;
int width, height;
gtk_icon_view_snapshot_item (GtkIconView *icon_view,
GtkSnapshot *snapshot,
GtkIconViewItem *item,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean draw_focus)
{
GdkRectangle cell_area;
GtkTreePath *path)
{
GList *l;
- gint index;
+ int index;
index = gtk_tree_path_get_indices (path)[0];
GtkIconViewItem *
_gtk_icon_view_get_item_at_coords (GtkIconView *icon_view,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean only_in_cell,
GtkCellRenderer **cell_at_pos)
{
gpointer data)
{
GtkIconView *icon_view = GTK_ICON_VIEW (data);
- gint index;
+ int index;
GtkIconViewItem *item;
GList *list;
gpointer data)
{
GtkIconView *icon_view = GTK_ICON_VIEW (data);
- gint index;
+ int index;
GtkIconViewItem *item;
GList *list, *next;
gboolean emit = FALSE;
gtk_icon_view_rows_reordered (GtkTreeModel *model,
GtkTreePath *parent,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer data)
{
GtkIconView *icon_view = GTK_ICON_VIEW (data);
int length;
GList *items = NULL, *list;
GtkIconViewItem **item_array;
- gint *order;
+ int *order;
/* ignore changes in branches */
if (iter != NULL)
length = gtk_tree_model_iter_n_children (model, NULL);
- order = g_new (gint, length);
+ order = g_new (int, length);
for (i = 0; i < length; i++)
order [new_order[i]] = i;
guint keyval,
guint modmask,
GtkMovementStep step,
- gint count)
+ int count)
{
gtk_widget_class_add_binding_signal (widget_class,
static gboolean
gtk_icon_view_real_move_cursor (GtkIconView *icon_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify)
{
static GtkIconViewItem *
find_item (GtkIconView *icon_view,
GtkIconViewItem *current,
- gint row_ofs,
- gint col_ofs)
+ int row_ofs,
+ int col_ofs)
{
- gint row, col;
+ int row, col;
GList *items;
GtkIconViewItem *item;
static GtkIconViewItem *
find_item_page_up_down (GtkIconView *icon_view,
GtkIconViewItem *current,
- gint count)
+ int count)
{
GList *item, *next;
- gint y, col;
+ int y, col;
col = current->col;
y = current->cell_area.y + count * gtk_adjustment_get_page_size (icon_view->priv->vadjustment);
{
GList *items;
GtkIconViewItem *item;
- gint row1, row2, col1, col2;
+ int row1, row2, col1, col2;
gboolean dirty = FALSE;
if (anchor->row < cursor->row)
static void
gtk_icon_view_move_cursor_up_down (GtkIconView *icon_view,
- gint count)
+ int count)
{
GtkIconViewItem *item;
GtkCellRenderer *cell = NULL;
gboolean dirty = FALSE;
- gint step;
+ int step;
GtkDirectionType direction;
if (!gtk_widget_has_focus (GTK_WIDGET (icon_view)))
static void
gtk_icon_view_move_cursor_page_up_down (GtkIconView *icon_view,
- gint count)
+ int count)
{
GtkIconViewItem *item;
gboolean dirty = FALSE;
static void
gtk_icon_view_move_cursor_left_right (GtkIconView *icon_view,
- gint count)
+ int count)
{
GtkIconViewItem *item;
GtkCellRenderer *cell = NULL;
gboolean dirty = FALSE;
- gint step;
+ int step;
GtkDirectionType direction;
if (!gtk_widget_has_focus (GTK_WIDGET (icon_view)))
static void
gtk_icon_view_move_cursor_start_end (GtkIconView *icon_view,
- gint count)
+ int count)
{
GtkIconViewItem *item;
GList *list;
if (use_align)
{
int width, height;
- gint x, y;
+ int x, y;
gfloat offset;
GdkRectangle item_area =
{
GtkWidget *widget = GTK_WIDGET (icon_view);
GtkAdjustment *hadj, *vadj;
int widget_width, widget_height;
- gint x, y;
+ int x, y;
GdkRectangle item_area;
item_area.x = item->cell_area.x - priv->item_padding;
**/
GtkTreePath *
gtk_icon_view_get_path_at_pos (GtkIconView *icon_view,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkIconViewItem *item;
GtkTreePath *path;
**/
gboolean
gtk_icon_view_get_item_at_pos (GtkIconView *icon_view,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path,
GtkCellRenderer **cell)
{
*/
gboolean
gtk_icon_view_get_tooltip_context (GtkIconView *icon_view,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
gboolean keyboard_tip,
GtkTreeModel **model,
GtkTreePath **path,
static gboolean
gtk_icon_view_set_tooltip_query_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
*/
void
gtk_icon_view_set_tooltip_column (GtkIconView *icon_view,
- gint column)
+ int column)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
* Returns: the index of the tooltip column that is currently being
* used, or -1 if this is disabled.
*/
-gint
+int
gtk_icon_view_get_tooltip_column (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), 0);
GtkTreePath **start_path,
GtkTreePath **end_path)
{
- gint start_index = -1;
- gint end_index = -1;
+ int start_index = -1;
+ int end_index = -1;
GList *icons;
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), FALSE);
**/
void
gtk_icon_view_set_text_column (GtkIconView *icon_view,
- gint column)
+ int column)
{
if (column == icon_view->priv->text_column)
return;
*
* Returns: the text column, or -1 if it’s unset.
*/
-gint
+int
gtk_icon_view_get_text_column (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
**/
void
gtk_icon_view_set_markup_column (GtkIconView *icon_view,
- gint column)
+ int column)
{
if (column == icon_view->priv->markup_column)
return;
*
* Returns: the markup column, or -1 if it’s unset.
*/
-gint
+int
gtk_icon_view_get_markup_column (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
**/
void
gtk_icon_view_set_pixbuf_column (GtkIconView *icon_view,
- gint column)
+ int column)
{
if (column == icon_view->priv->pixbuf_column)
return;
*
* Returns: the pixbuf column, or -1 if it’s unset.
*/
-gint
+int
gtk_icon_view_get_pixbuf_column (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*
* Returns: The row in which the item is displayed
*/
-gint
+int
gtk_icon_view_get_item_row (GtkIconView *icon_view,
GtkTreePath *path)
{
*
* Returns: The column in which the item is displayed
*/
-gint
+int
gtk_icon_view_get_item_column (GtkIconView *icon_view,
GtkTreePath *path)
{
*/
void
gtk_icon_view_set_columns (GtkIconView *icon_view,
- gint columns)
+ int columns)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the number of columns, or -1
*/
-gint
+int
gtk_icon_view_get_columns (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*/
void
gtk_icon_view_set_item_width (GtkIconView *icon_view,
- gint item_width)
+ int item_width)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the width of a single item, or -1
*/
-gint
+int
gtk_icon_view_get_item_width (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*/
void
gtk_icon_view_set_spacing (GtkIconView *icon_view,
- gint spacing)
+ int spacing)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the space between cells
*/
-gint
+int
gtk_icon_view_get_spacing (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*/
void
gtk_icon_view_set_row_spacing (GtkIconView *icon_view,
- gint row_spacing)
+ int row_spacing)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the space between rows
*/
-gint
+int
gtk_icon_view_get_row_spacing (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*/
void
gtk_icon_view_set_column_spacing (GtkIconView *icon_view,
- gint column_spacing)
+ int column_spacing)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the space between columns
*/
-gint
+int
gtk_icon_view_get_column_spacing (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*/
void
gtk_icon_view_set_margin (GtkIconView *icon_view,
- gint margin)
+ int margin)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the space at the borders
*/
-gint
+int
gtk_icon_view_get_margin (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
*/
void
gtk_icon_view_set_item_padding (GtkIconView *icon_view,
- gint item_padding)
+ int item_padding)
{
g_return_if_fail (GTK_IS_ICON_VIEW (icon_view));
*
* Returns: the padding around items
*/
-gint
+int
gtk_icon_view_get_item_padding (GtkIconView *icon_view)
{
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), -1);
static void
gtk_icon_view_autoscroll (GtkIconView *icon_view)
{
- gint px, py, width, height;
- gint hoffset, voffset;
+ int px, py, width, height;
+ int hoffset, voffset;
px = icon_view->priv->event_last_x;
py = icon_view->priv->event_last_y;
static gboolean
set_destination (GtkIconView *icon_view,
GtkDropTargetAsync *dest,
- gint x,
- gint y,
+ int x,
+ int y,
GdkDragAction *suggested_action,
GType *target)
{
if (!gtk_icon_view_get_dest_item_at_pos (icon_view, x, y, &path, &pos))
{
- gint n_children;
+ int n_children;
GtkTreeModel *model;
/* the row got dropped on empty space, let's setup a special case
&& gtk_tree_path_get_depth (path) == 1
&& gtk_tree_path_get_indices (path)[0] == 0)
{
- gint n_children;
+ int n_children;
n_children = gtk_tree_model_iter_n_children (icon_view->priv->model,
NULL);
**/
gboolean
gtk_icon_view_get_dest_item_at_pos (GtkIconView *icon_view,
- gint drag_x,
- gint drag_y,
+ int drag_x,
+ int drag_y,
GtkTreePath **path,
GtkIconViewDropPosition *pos)
{
GtkSnapshot *snapshot;
GdkPaintable *paintable;
GList *l;
- gint index;
+ int index;
g_return_val_if_fail (GTK_IS_ICON_VIEW (icon_view), NULL);
g_return_val_if_fail (path != NULL, NULL);
GtkTreeModel * gtk_icon_view_get_model (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_text_column (GtkIconView *icon_view,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_text_column (GtkIconView *icon_view);
+int gtk_icon_view_get_text_column (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_markup_column (GtkIconView *icon_view,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_markup_column (GtkIconView *icon_view);
+int gtk_icon_view_get_markup_column (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_pixbuf_column (GtkIconView *icon_view,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_pixbuf_column (GtkIconView *icon_view);
+int gtk_icon_view_get_pixbuf_column (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_item_orientation (GtkIconView *icon_view,
GtkOrientation gtk_icon_view_get_item_orientation (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_columns (GtkIconView *icon_view,
- gint columns);
+ int columns);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_columns (GtkIconView *icon_view);
+int gtk_icon_view_get_columns (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_item_width (GtkIconView *icon_view,
- gint item_width);
+ int item_width);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_item_width (GtkIconView *icon_view);
+int gtk_icon_view_get_item_width (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_spacing (GtkIconView *icon_view,
- gint spacing);
+ int spacing);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_spacing (GtkIconView *icon_view);
+int gtk_icon_view_get_spacing (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_row_spacing (GtkIconView *icon_view,
- gint row_spacing);
+ int row_spacing);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_row_spacing (GtkIconView *icon_view);
+int gtk_icon_view_get_row_spacing (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_column_spacing (GtkIconView *icon_view,
- gint column_spacing);
+ int column_spacing);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_column_spacing (GtkIconView *icon_view);
+int gtk_icon_view_get_column_spacing (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_margin (GtkIconView *icon_view,
- gint margin);
+ int margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_margin (GtkIconView *icon_view);
+int gtk_icon_view_get_margin (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_item_padding (GtkIconView *icon_view,
- gint item_padding);
+ int item_padding);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_item_padding (GtkIconView *icon_view);
+int gtk_icon_view_get_item_padding (GtkIconView *icon_view);
GDK_AVAILABLE_IN_ALL
GtkTreePath * gtk_icon_view_get_path_at_pos (GtkIconView *icon_view,
- gint x,
- gint y);
+ int x,
+ int y);
GDK_AVAILABLE_IN_ALL
gboolean gtk_icon_view_get_item_at_pos (GtkIconView *icon_view,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path,
GtkCellRenderer **cell);
GDK_AVAILABLE_IN_ALL
gboolean gtk_icon_view_path_is_selected (GtkIconView *icon_view,
GtkTreePath *path);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_item_row (GtkIconView *icon_view,
+int gtk_icon_view_get_item_row (GtkIconView *icon_view,
GtkTreePath *path);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_item_column (GtkIconView *icon_view,
+int gtk_icon_view_get_item_column (GtkIconView *icon_view,
GtkTreePath *path);
GDK_AVAILABLE_IN_ALL
GList *gtk_icon_view_get_selected_items (GtkIconView *icon_view);
GtkIconViewDropPosition *pos);
GDK_AVAILABLE_IN_ALL
gboolean gtk_icon_view_get_dest_item_at_pos (GtkIconView *icon_view,
- gint drag_x,
- gint drag_y,
+ int drag_x,
+ int drag_y,
GtkTreePath **path,
GtkIconViewDropPosition *pos);
GDK_AVAILABLE_IN_ALL
GtkCellRenderer *cell);
GDK_AVAILABLE_IN_ALL
gboolean gtk_icon_view_get_tooltip_context (GtkIconView *icon_view,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
gboolean keyboard_tip,
GtkTreeModel **model,
GtkTreePath **path,
GtkTreeIter *iter);
GDK_AVAILABLE_IN_ALL
void gtk_icon_view_set_tooltip_column (GtkIconView *icon_view,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
-gint gtk_icon_view_get_tooltip_column (GtkIconView *icon_view);
+int gtk_icon_view_get_tooltip_column (GtkIconView *icon_view);
G_END_DECLS
{
GdkRectangle cell_area;
- gint index;
+ int index;
- gint row, col;
+ int row, col;
guint selected : 1;
guint selected_before_rubberbanding : 1;
void (* toggle_cursor_item) (GtkIconView *icon_view);
gboolean (* move_cursor) (GtkIconView *icon_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
gboolean (* activate_cursor_item) (GtkIconView *icon_view);
GPtrArray *row_contexts;
- gint width, height;
+ int width, height;
double mouse_x;
double mouse_y;
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
- gint rubberband_x1, rubberband_y1;
- gint rubberband_x2, rubberband_y2;
+ int rubberband_x1, rubberband_y1;
+ int rubberband_x2, rubberband_y2;
GdkDevice *rubberband_device;
GtkCssNode *rubberband_node;
guint scroll_timeout_id;
- gint scroll_value_diff;
- gint event_last_x, event_last_y;
+ int scroll_value_diff;
+ int event_last_x, event_last_y;
GtkIconViewItem *anchor_item;
GtkIconViewItem *cursor_item;
GtkOrientation item_orientation;
- gint columns;
- gint item_width;
- gint spacing;
- gint row_spacing;
- gint column_spacing;
- gint margin;
- gint item_padding;
+ int columns;
+ int item_width;
+ int spacing;
+ int row_spacing;
+ int column_spacing;
+ int margin;
+ int item_padding;
- gint text_column;
- gint markup_column;
- gint pixbuf_column;
- gint tooltip_column;
+ int text_column;
+ int markup_column;
+ int pixbuf_column;
+ int tooltip_column;
GtkCellRenderer *pixbuf_cell;
GtkCellRenderer *text_cell;
/* Drag-and-drop. */
GdkModifierType start_button_mask;
- gint pressed_button;
- gint press_start_x;
- gint press_start_y;
+ int pressed_button;
+ int press_start_x;
+ int press_start_y;
GdkContentFormats *source_formats;
GtkDropTargetAsync *dest;
GtkIconViewItem *item,
GtkCellRenderer *cursor_cell);
GtkIconViewItem * _gtk_icon_view_get_item_at_coords (GtkIconView *icon_view,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean only_in_cell,
GtkCellRenderer **cell_at_pos);
void _gtk_icon_view_select_item (GtkIconView *icon_view,
typedef struct {
GtkImage *image;
- gint scale_factor;
+ int scale_factor;
} LoaderData;
static void
on_loader_size_prepared (GdkPixbufLoader *loader,
- gint width,
- gint height,
+ int width,
+ int height,
gpointer user_data)
{
LoaderData *loader_data = user_data;
- gint scale_factor;
+ int scale_factor;
GdkPixbufFormat *format;
/* Let the regular icon helper code path handle non-scalable images */
load_scalable_with_loader (GtkImage *image,
const gchar *file_path,
const gchar *resource_path,
- gint *scale_factor_out)
+ int *scale_factor_out)
{
GdkPixbufLoader *loader;
GBytes *bytes;
const gchar *filename)
{
GdkPixbufAnimation *anim;
- gint scale_factor;
+ int scale_factor;
GdkTexture *texture;
GdkPaintable *scaler;
const gchar *resource_path)
{
GdkPixbufAnimation *animation;
- gint scale_factor = 1;
+ int scale_factor = 1;
GdkTexture *texture;
GdkPaintable *scaler;
*/
void
gtk_image_set_pixel_size (GtkImage *image,
- gint pixel_size)
+ int pixel_size)
{
g_return_if_fail (GTK_IS_IMAGE (image));
*
* Returns: the pixel size used for named icons.
*/
-gint
+int
gtk_image_get_pixel_size (GtkImage *image)
{
g_return_val_if_fail (GTK_IS_IMAGE (image), -1);
GIcon *icon);
GDK_AVAILABLE_IN_ALL
void gtk_image_set_pixel_size (GtkImage *image,
- gint pixel_size);
+ int pixel_size);
GDK_AVAILABLE_IN_ALL
void gtk_image_set_icon_size (GtkImage *image,
GtkIconSize icon_size);
GDK_AVAILABLE_IN_ALL
GIcon * gtk_image_get_gicon (GtkImage *image);
GDK_AVAILABLE_IN_ALL
-gint gtk_image_get_pixel_size (GtkImage *image);
+int gtk_image_get_pixel_size (GtkImage *image);
GDK_AVAILABLE_IN_ALL
GtkIconSize gtk_image_get_icon_size (GtkImage *image);
struct _GtkImageDefinitionEmpty {
GtkImageType type;
- gint ref_count;
+ int ref_count;
};
struct _GtkImageDefinitionIconName {
GtkImageType type;
- gint ref_count;
+ int ref_count;
char *icon_name;
};
struct _GtkImageDefinitionGIcon {
GtkImageType type;
- gint ref_count;
+ int ref_count;
GIcon *gicon;
};
struct _GtkImageDefinitionPaintable {
GtkImageType type;
- gint ref_count;
+ int ref_count;
GdkPaintable *paintable;
};
return def->type;
}
-gint
+int
gtk_image_definition_get_scale (const GtkImageDefinition *def)
{
switch (def->type)
void gtk_image_definition_unref (GtkImageDefinition *def);
GtkImageType gtk_image_definition_get_storage_type (const GtkImageDefinition *def);
-gint gtk_image_definition_get_scale (const GtkImageDefinition *def);
+int gtk_image_definition_get_scale (const GtkImageDefinition *def);
const gchar * gtk_image_definition_get_icon_name (const GtkImageDefinition *def);
GIcon * gtk_image_definition_get_gicon (const GtkImageDefinition *def);
GdkPaintable * gtk_image_definition_get_paintable (const GtkImageDefinition *def);
static void gtk_im_context_real_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos);
+ int *cursor_pos);
static gboolean gtk_im_context_real_filter_keypress (GtkIMContext *context,
GdkEvent *event);
static gboolean gtk_im_context_real_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index);
+ int *cursor_index);
static void gtk_im_context_real_set_surrounding (GtkIMContext *context,
const char *text,
- gint len,
- gint cursor_index);
+ int len,
+ int cursor_index);
static void gtk_im_context_get_property (GObject *obj,
guint property_id,
gtk_im_context_real_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
if (str)
*str = g_strdup ("");
typedef struct
{
gchar *text;
- gint cursor_index;
+ int cursor_index;
} SurroundingInfo;
static void
gtk_im_context_real_set_surrounding (GtkIMContext *context,
const gchar *text,
- gint len,
- gint cursor_index)
+ int len,
+ int cursor_index)
{
SurroundingInfo *info = g_object_get_data (G_OBJECT (context),
"gtk-im-surrounding-info");
static gboolean
gtk_im_context_real_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index)
+ int *cursor_index)
{
gboolean result;
gboolean info_is_local = FALSE;
gtk_im_context_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
GtkIMContextClass *klass;
void
gtk_im_context_set_surrounding (GtkIMContext *context,
const gchar *text,
- gint len,
- gint cursor_index)
+ int len,
+ int cursor_index)
{
GtkIMContextClass *klass;
gboolean
gtk_im_context_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index)
+ int *cursor_index)
{
GtkIMContextClass *klass;
gchar *local_text = NULL;
- gint local_index;
+ int local_index;
gboolean result = FALSE;
g_return_val_if_fail (GTK_IS_IM_CONTEXT (context), FALSE);
**/
gboolean
gtk_im_context_delete_surrounding (GtkIMContext *context,
- gint offset,
- gint n_chars)
+ int offset,
+ int n_chars)
{
gboolean result;
void (*commit) (GtkIMContext *context, const gchar *str);
gboolean (*retrieve_surrounding) (GtkIMContext *context);
gboolean (*delete_surrounding) (GtkIMContext *context,
- gint offset,
- gint n_chars);
+ int offset,
+ int n_chars);
/* Virtual functions */
void (*set_client_widget) (GtkIMContext *context,
void (*get_preedit_string) (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos);
+ int *cursor_pos);
gboolean (*filter_keypress) (GtkIMContext *context,
GdkEvent *event);
void (*focus_in) (GtkIMContext *context);
gboolean use_preedit);
void (*set_surrounding) (GtkIMContext *context,
const gchar *text,
- gint len,
- gint cursor_index);
+ int len,
+ int cursor_index);
gboolean (*get_surrounding) (GtkIMContext *context,
gchar **text,
- gint *cursor_index);
+ int *cursor_index);
/*< private >*/
/* Padding for future expansion */
void (*_gtk_reserved1) (void);
void gtk_im_context_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos);
+ int *cursor_pos);
GDK_AVAILABLE_IN_ALL
gboolean gtk_im_context_filter_keypress (GtkIMContext *context,
GdkEvent *event);
GDK_AVAILABLE_IN_ALL
void gtk_im_context_set_surrounding (GtkIMContext *context,
const gchar *text,
- gint len,
- gint cursor_index);
+ int len,
+ int cursor_index);
GDK_AVAILABLE_IN_ALL
gboolean gtk_im_context_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index);
+ int *cursor_index);
GDK_AVAILABLE_IN_ALL
gboolean gtk_im_context_delete_surrounding (GtkIMContext *context,
- gint offset,
- gint n_chars);
+ int offset,
+ int n_chars);
G_END_DECLS
static void gtk_im_context_ime_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos);
+ int *cursor_pos);
static void gtk_im_context_ime_focus_in (GtkIMContext *context);
static void gtk_im_context_ime_focus_out (GtkIMContext *context);
static void gtk_im_context_ime_set_cursor_location (GtkIMContext *context,
static GdkWin32MessageFilterReturn
gtk_im_context_ime_message_filter (GdkWin32Display *display,
MSG *msg,
- gint *ret_valp,
+ int *ret_valp,
gpointer data);
static void get_window_position (GdkSurface *win,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
G_DEFINE_TYPE_WITH_CODE (GtkIMContextIME, gtk_im_context_ime, GTK_TYPE_IM_CONTEXT,
gtk_im_module_ensure_extension_point ();
static gchar *
-get_utf8_preedit_string (GtkIMContextIME *context_ime, gint *pos_ret)
+get_utf8_preedit_string (GtkIMContextIME *context_ime, int *pos_ret)
{
gchar *utf8str = NULL;
HWND hwnd;
HIMC himc;
- gint pos = 0;
+ int pos = 0;
if (pos_ret)
*pos_ret = 0;
gtk_im_context_ime_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
gchar *utf8str = NULL;
- gint pos = 0;
+ int pos = 0;
GtkIMContextIME *context_ime;
context_ime = GTK_IM_CONTEXT_IME (context);
gtk_im_context_ime_set_cursor_location (GtkIMContext *context,
GdkRectangle *area)
{
- gint wx = 0, wy = 0;
+ int wx = 0, wy = 0;
GtkIMContextIME *context_ime;
COMPOSITIONFORM cf;
HWND hwnd;
static GdkWin32MessageFilterReturn
gtk_im_context_ime_message_filter (GdkWin32Display *display,
MSG *msg,
- gint *ret_valp,
+ int *ret_valp,
gpointer data)
{
GtkIMContext *context;
{
case WM_IME_COMPOSITION:
{
- gint wx = 0, wy = 0;
+ int wx = 0, wy = 0;
CANDIDATEFORM cf;
get_window_position (context_ime->client_surface, &wx, &wy);
* x and y must be initialized to 0.
*/
static void
-get_window_position (GdkSurface *surface, gint *x, gint *y)
+get_window_position (GdkSurface *surface, int *x, int *y)
{
GdkSurface *parent, *toplevel;
quartz_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
GtkIMContextQuartz *qc = GTK_IM_CONTEXT_QUARTZ (context);
quartz_set_cursor_location (GtkIMContext *context, GdkRectangle *area)
{
GtkIMContextQuartz *qc = GTK_IM_CONTEXT_QUARTZ (context);
- gint x, y;
+ int x, y;
NSView *nsview;
GdkSurface *surface;
{
guint16 compose_buffer[GTK_MAX_COMPOSE_LEN + 1];
gunichar tentative_match;
- gint tentative_match_len;
+ int tentative_match_len;
guint in_hex_sequence : 1;
guint modifiers_dropped : 1;
static void gtk_im_context_simple_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos);
+ int *cursor_pos);
static void init_compose_table_async (GCancellable *cancellable,
GAsyncReadyCallback callback,
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
GtkIMContextSimplePrivate *priv = context_simple->priv;
gchar buf[10];
- gint len;
+ int len;
g_return_if_fail (g_unichar_validate (ch));
static gboolean
check_table (GtkIMContextSimple *context_simple,
const GtkComposeTable *table,
- gint n_compose)
+ int n_compose)
{
GtkIMContextSimplePrivate *priv = context_simple->priv;
- gint row_stride = table->max_seq_len + 2;
+ int row_stride = table->max_seq_len + 2;
guint16 *seq;
/* Will never match, if the sequence in the compose buffer is longer
gboolean
gtk_check_compact_table (const GtkComposeTableCompact *table,
guint16 *compose_buffer,
- gint n_compose,
+ int n_compose,
gboolean *compose_finish,
gboolean *compose_match,
gunichar *output_char)
{
- gint row_stride;
+ int row_stride;
guint16 *seq_index;
guint16 *seq;
- gint i;
+ int i;
gboolean match;
gunichar value;
* permutations of the diacritic marks, then attempt to normalize.
*/
static gboolean
-check_normalize_nfc (gunichar* combination_buffer, gint n_compose)
+check_normalize_nfc (gunichar* combination_buffer, int n_compose)
{
gunichar combination_buffer_temp[GTK_MAX_COMPOSE_LEN];
gchar *combination_utf8_temp = NULL;
gchar *nfc_temp = NULL;
- gint n_combinations;
+ int n_combinations;
gunichar temp_swap;
- gint i;
+ int i;
n_combinations = 1;
gboolean
gtk_check_algorithmically (const guint16 *compose_buffer,
- gint n_compose,
+ int n_compose,
gunichar *output_char)
{
- gint i;
+ int i;
gunichar combination_buffer[GTK_MAX_COMPOSE_LEN];
gchar *combination_utf8, *nfc;
static gboolean
check_hex (GtkIMContextSimple *context_simple,
- gint n_compose)
+ int n_compose)
{
GtkIMContextSimplePrivate *priv = context_simple->priv;
/* See if this is a hex sequence, return TRUE if so */
- gint i;
+ int i;
GString *str;
gulong n;
gchar *nptr = NULL;
static gboolean
no_sequence_matches (GtkIMContextSimple *context_simple,
- gint n_compose,
+ int n_compose,
GdkEvent *event)
{
GtkIMContextSimplePrivate *priv = context_simple->priv;
*/
if (priv->tentative_match)
{
- gint len = priv->tentative_match_len;
+ int len = priv->tentative_match_len;
int i;
gtk_im_context_simple_commit_char (context, priv->tentative_match);
{
guint keyval, event_keyval;
guint *keyvals = NULL;
- gint n_vals = 0;
- gint i;
+ int n_vals = 0;
+ int i;
event_keyval = gdk_key_event_get_keyval (event);
gtk_im_context_simple_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
GtkIMContextSimple *context_simple = GTK_IM_CONTEXT_SIMPLE (context);
GtkIMContextSimplePrivate *priv = context_simple->priv;
void
gtk_im_context_simple_add_table (GtkIMContextSimple *context_simple,
guint16 *data,
- gint max_seq_len,
- gint n_seqs)
+ int max_seq_len,
+ int n_seqs)
{
g_return_if_fail (GTK_IS_IM_CONTEXT_SIMPLE (context_simple));
GDK_AVAILABLE_IN_ALL
void gtk_im_context_simple_add_table (GtkIMContextSimple *context_simple,
guint16 *data,
- gint max_seq_len,
- gint n_seqs);
+ int max_seq_len,
+ int n_seqs);
GDK_AVAILABLE_IN_ALL
void gtk_im_context_simple_add_compose_file (GtkIMContextSimple *context_simple,
const gchar *compose_file);
extern const GtkComposeTableCompact gtk_compose_table_compact;
gboolean gtk_check_algorithmically (const guint16 *compose_buffer,
- gint n_compose,
+ int n_compose,
gunichar *output);
gboolean gtk_check_compact_table (const GtkComposeTableCompact *table,
guint16 *compose_buffer,
- gint n_compose,
+ int n_compose,
gboolean *compose_finish,
gboolean *compose_match,
gunichar *output_char);
struct preedit {
gchar *text;
- gint cursor_begin;
- gint cursor_end;
+ int cursor_begin;
+ int cursor_end;
};
struct surrounding_delete {
struct {
gchar *text;
- gint cursor_idx;
- gint anchor_idx;
+ int cursor_idx;
+ int anchor_idx;
} surrounding;
enum zwp_text_input_v3_change_cause surrounding_change;
text_input_preedit (void *data,
struct zwp_text_input_v3 *text_input,
const char *text,
- gint cursor_begin,
- gint cursor_end)
+ int cursor_begin,
+ int cursor_end)
{
GtkIMContextWayland *context;
GtkIMContextWaylandGlobal *global = data;
{
GtkIMContextWayland *context;
gboolean retval;
- gint len;
+ int len;
struct surrounding_delete defaults = {0};
context = GTK_IM_CONTEXT_WAYLAND (global->current);
static void
pressed_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkIMContextWayland *context)
static void
released_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkIMContextWayland *context)
gtk_im_context_wayland_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
GtkIMContextWayland *context_wayland = GTK_IM_CONTEXT_WAYLAND (context);
const char *preedit_str;
static void
gtk_im_context_wayland_set_surrounding (GtkIMContext *context,
const gchar *text,
- gint len,
- gint cursor_index)
+ int len,
+ int cursor_index)
{
GtkIMContextWayland *context_wayland;
static gboolean
gtk_im_context_wayland_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index)
+ int *cursor_index)
{
GtkIMContextWayland *context_wayland;
static void gtk_im_multicontext_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos);
+ int *cursor_pos);
static gboolean gtk_im_multicontext_filter_keypress (GtkIMContext *context,
GdkEvent *event);
static void gtk_im_multicontext_focus_in (GtkIMContext *context);
gboolean use_preedit);
static gboolean gtk_im_multicontext_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index);
+ int *cursor_index);
static void gtk_im_multicontext_set_surrounding (GtkIMContext *context,
const char *text,
- gint len,
- gint cursor_index);
+ int len,
+ int cursor_index);
static void gtk_im_multicontext_preedit_start_cb (GtkIMContext *delegate,
GtkIMMulticontext *multicontext);
static gboolean gtk_im_multicontext_retrieve_surrounding_cb (GtkIMContext *delegate,
GtkIMMulticontext *multicontext);
static gboolean gtk_im_multicontext_delete_surrounding_cb (GtkIMContext *delegate,
- gint offset,
- gint n_chars,
+ int offset,
+ int n_chars,
GtkIMMulticontext *multicontext);
static void propagate_purpose (GtkIMMulticontext *context);
gtk_im_multicontext_get_preedit_string (GtkIMContext *context,
gchar **str,
PangoAttrList **attrs,
- gint *cursor_pos)
+ int *cursor_pos)
{
GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
GtkIMContext *delegate = gtk_im_multicontext_get_delegate (multicontext);
ch = gdk_keyval_to_unicode (keyval);
if (ch != 0 && !g_unichar_iscntrl (ch))
{
- gint len;
+ int len;
gchar buf[10];
len = g_unichar_to_utf8 (ch, buf);
static gboolean
gtk_im_multicontext_get_surrounding (GtkIMContext *context,
gchar **text,
- gint *cursor_index)
+ int *cursor_index)
{
GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
GtkIMContext *delegate = gtk_im_multicontext_get_delegate (multicontext);
static void
gtk_im_multicontext_set_surrounding (GtkIMContext *context,
const char *text,
- gint len,
- gint cursor_index)
+ int len,
+ int cursor_index)
{
GtkIMMulticontext *multicontext = GTK_IM_MULTICONTEXT (context);
GtkIMContext *delegate = gtk_im_multicontext_get_delegate (multicontext);
static gboolean
gtk_im_multicontext_delete_surrounding_cb (GtkIMContext *delegate,
- gint offset,
- gint n_chars,
+ int offset,
+ int n_chars,
GtkIMMulticontext *multicontext)
{
gboolean result;
{
GtkWidgetClass parent_class;
- void (* response) (GtkInfoBar *info_bar, gint response_id);
+ void (* response) (GtkInfoBar *info_bar, int response_id);
void (* close) (GtkInfoBar *info_bar);
};
static GtkWidget *
find_button (GtkInfoBar *info_bar,
- gint response_id)
+ int response_id)
{
GtkWidget *child;
iface->custom_finished = gtk_info_bar_buildable_custom_finished;
}
-static gint
+static int
get_response_for_widget (GtkInfoBar *info_bar,
GtkWidget *widget)
{
action_widget_activated (GtkWidget *widget,
GtkInfoBar *info_bar)
{
- gint response_id;
+ int response_id;
response_id = get_response_for_widget (info_bar, widget);
gtk_info_bar_response (info_bar, response_id);
void
gtk_info_bar_add_action_widget (GtkInfoBar *info_bar,
GtkWidget *child,
- gint response_id)
+ int response_id)
{
ResponseData *ad;
guint signal_id;
GtkWidget*
gtk_info_bar_add_button (GtkInfoBar *info_bar,
const gchar *button_text,
- gint response_id)
+ int response_id)
{
GtkWidget *button;
va_list args)
{
const gchar* text;
- gint response_id;
+ int response_id;
g_return_if_fail (GTK_IS_INFO_BAR (info_bar));
return;
text = first_button_text;
- response_id = va_arg (args, gint);
+ response_id = va_arg (args, int);
while (text != NULL)
{
*/
void
gtk_info_bar_set_response_sensitive (GtkInfoBar *info_bar,
- gint response_id,
+ int response_id,
gboolean setting)
{
GtkWidget *child;
*/
void
gtk_info_bar_set_default_response (GtkInfoBar *info_bar,
- gint response_id)
+ int response_id)
{
GtkWidget *child;
GtkWidget *window;
*/
void
gtk_info_bar_response (GtkInfoBar *info_bar,
- gint response_id)
+ int response_id)
{
g_return_if_fail (GTK_IS_INFO_BAR (info_bar));
typedef struct
{
gchar *name;
- gint response_id;
- gint line;
- gint col;
+ int response_id;
+ int line;
+ int col;
} ActionWidgetInfo;
typedef struct
GtkInfoBar *info_bar;
GtkBuilder *builder;
GSList *items;
- gint response_id;
+ int response_id;
gboolean is_text;
GString *string;
- gint line;
- gint col;
+ int line;
+ int col;
} SubParserData;
static void
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_add_action_widget (GtkInfoBar *info_bar,
GtkWidget *child,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_remove_action_widget (GtkInfoBar *info_bar,
GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
GtkWidget *gtk_info_bar_add_button (GtkInfoBar *info_bar,
const gchar *button_text,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_add_buttons (GtkInfoBar *info_bar,
const gchar *first_button_text,
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_set_response_sensitive (GtkInfoBar *info_bar,
- gint response_id,
+ int response_id,
gboolean setting);
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_set_default_response (GtkInfoBar *info_bar,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_response (GtkInfoBar *info_bar,
- gint response_id);
+ int response_id);
GDK_AVAILABLE_IN_ALL
void gtk_info_bar_set_message_type (GtkInfoBar *info_bar,
guint mnemonic_keyval;
- gint width_chars;
- gint max_width_chars;
- gint lines;
+ int width_chars;
+ int max_width_chars;
+ int lines;
};
struct _GtkLabelClass
void (* move_cursor) (GtkLabel *self,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend_selection);
void (* copy_clipboard) (GtkLabel *self);
gboolean visited; /* get set when the link is activated; this flag
* gets preserved over later set_markup() calls
*/
- gint start; /* position of the link in the PangoLayout */
- gint end;
+ int start; /* position of the link in the PangoLayout */
+ int end;
} GtkLabelLink;
struct _GtkLabelSelectionInfo
{
- gint selection_anchor;
- gint selection_end;
+ int selection_anchor;
+ int selection_end;
GtkCssNode *selection_node;
GdkContentProvider *provider;
GtkGesture *click_gesture;
GtkEventController *motion_controller;
- gint drag_start_x;
- gint drag_start_y;
+ int drag_start_x;
+ int drag_start_y;
guint in_drag : 1;
guint select_words : 1;
static gboolean gtk_label_grab_focus (GtkWidget *widget);
static gboolean gtk_label_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip);
static void gtk_label_clear_layout (GtkLabel *self);
static void gtk_label_ensure_layout (GtkLabel *self);
static void gtk_label_select_region_index (GtkLabel *self,
- gint anchor_index,
- gint end_index);
+ int anchor_index,
+ int end_index);
static void gtk_label_update_active_link (GtkWidget *widget,
gdouble x,
/* For selectable labels: */
static void gtk_label_move_cursor (GtkLabel *self,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend_selection);
static void gtk_label_copy_clipboard (GtkLabel *self);
static void gtk_label_select_all (GtkLabel *self);
-static gint gtk_label_move_forward_word (GtkLabel *self,
- gint start);
-static gint gtk_label_move_backward_word (GtkLabel *self,
- gint start);
+static int gtk_label_move_forward_word (GtkLabel *self,
+ int start);
+static int gtk_label_move_backward_word (GtkLabel *self,
+ int start);
/* For links: */
static void gtk_label_clear_links (GtkLabel *self);
/* Event controller callbacks */
static void gtk_label_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkLabel *self);
static void gtk_label_click_gesture_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkLabel *self);
guint keyval,
guint modmask,
GtkMovementStep step,
- gint count)
+ int count)
{
g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
const gchar *title = NULL;
const gchar *class = NULL;
gboolean visited = FALSE;
- gint line_number;
- gint char_number;
- gint i;
+ int line_number;
+ int char_number;
+ int i;
GtkCssNode *widget_node;
GtkStateFlags state;
}
else
{
- gint i;
+ int i;
g_string_append_c (pdata->new_str, '<');
g_string_append (pdata->new_str, element_name);
**/
void
gtk_label_set_width_chars (GtkLabel *self,
- gint n_chars)
+ int n_chars)
{
g_return_if_fail (GTK_IS_LABEL (self));
*
* Returns: the width of the label in characters.
**/
-gint
+int
gtk_label_get_width_chars (GtkLabel *self)
{
g_return_val_if_fail (GTK_IS_LABEL (self), -1);
**/
void
gtk_label_set_max_width_chars (GtkLabel *self,
- gint n_chars)
+ int n_chars)
{
g_return_if_fail (GTK_IS_LABEL (self));
*
* Returns: the maximum width of the label in characters.
**/
-gint
+int
gtk_label_get_max_width_chars (GtkLabel *self)
{
g_return_val_if_fail (GTK_IS_LABEL (self), -1);
static void
get_height_for_width (GtkLabel *self,
- gint width,
- gint *minimum_height,
- gint *natural_height,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int width,
+ int *minimum_height,
+ int *natural_height,
+ int *minimum_baseline,
+ int *natural_baseline)
{
PangoLayout *layout;
- gint text_height, baseline;
+ int text_height, baseline;
layout = gtk_label_get_measuring_layout (self, NULL, width * PANGO_SCALE);
g_object_unref (layout);
}
-static gint
+static int
get_char_pixels (GtkWidget *self,
PangoLayout *layout)
{
PangoContext *context;
PangoFontMetrics *metrics;
- gint char_width, digit_width;
+ int char_width, digit_width;
context = pango_layout_get_context (layout);
metrics = pango_context_get_metrics (context,
int *widest_baseline)
{
PangoLayout *layout;
- gint char_pixels;
+ int char_pixels;
/* "width-chars" Hard-coded minimum width:
* - minimum size should be MAX (width-chars, strlen ("..."));
static void
gtk_label_get_preferred_size (GtkWidget *widget,
GtkOrientation orientation,
- gint *minimum_size,
- gint *natural_size,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int *minimum_size,
+ int *natural_size,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkLabel *self = GTK_LABEL (widget);
PangoRectangle widest_rect;
static void
get_layout_location (GtkLabel *self,
- gint *xp,
- gint *yp)
+ int *xp,
+ int *yp)
{
GtkWidget *widget = GTK_WIDGET (self);
- gint req_width, x, y;
- gint req_height;
+ int req_width, x, y;
+ int req_height;
gfloat xalign, yalign;
PangoRectangle logical;
- gint baseline, layout_baseline, baseline_offset;
+ int baseline, layout_baseline, baseline_offset;
int label_width, label_height;
xalign = self->xalign;
GtkLabel *self = GTK_LABEL (widget);
GtkLabelSelectionInfo *info;
GtkStyleContext *context;
- gint lx, ly;
+ int lx, ly;
int width, height, x;
info = self->select_info;
if (info && (info->selection_anchor != info->selection_end))
{
- gint range[2];
+ int range[2];
cairo_region_t *range_clip;
cairo_rectangle_int_t clip_rect;
int i;
if (range[0] > range[1])
{
- gint tmp = range[0];
+ int tmp = range[0];
range[0] = range[1];
range[1] = tmp;
}
{
GtkLabelLink *focus_link;
GtkLabelLink *active_link;
- gint range[2];
+ int range[2];
cairo_region_t *range_clip;
cairo_rectangle_int_t clip_rect;
int i;
static gboolean
get_layout_index (GtkLabel *self,
- gint x,
- gint y,
- gint *index)
+ int x,
+ int y,
+ int *index)
{
- gint trailing = 0;
+ int trailing = 0;
const gchar *cluster;
const gchar *cluster_end;
gboolean inside;
static gboolean
range_is_in_ellipsis_full (GtkLabel *self,
- gint range_start,
- gint range_end,
- gint *ellipsis_start,
- gint *ellipsis_end)
+ int range_start,
+ int range_end,
+ int *ellipsis_start,
+ int *ellipsis_end)
{
PangoLayoutIter *iter;
gboolean in_ellipsis;
static gboolean
range_is_in_ellipsis (GtkLabel *self,
- gint range_start,
- gint range_end)
+ int range_start,
+ int range_end)
{
return range_is_in_ellipsis_full (self, range_start, range_end, NULL, NULL);
}
static void
gtk_label_select_word (GtkLabel *self)
{
- gint min, max;
+ int min, max;
- gint start_index = gtk_label_move_backward_word (self, self->select_info->selection_end);
- gint end_index = gtk_label_move_forward_word (self, self->select_info->selection_end);
+ int start_index = gtk_label_move_backward_word (self, self->select_info->selection_end);
+ int end_index = gtk_label_move_forward_word (self, self->select_info->selection_end);
min = MIN (self->select_info->selection_anchor,
self->select_info->selection_end);
if (info->selectable)
{
- gint index;
+ int index;
if (info->selection_anchor != info->selection_end)
goto out;
static void
gtk_label_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble widget_x,
gdouble widget_y,
GtkLabel *self)
static void
gtk_label_click_gesture_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkLabel *self)
{
GtkLabelSelectionInfo *info = self->select_info;
GdkEventSequence *sequence;
- gint index;
+ int index;
if (info == NULL)
return;
self->select_info->selection_end) &&
self->text)
{
- gint start, end;
- gint len;
+ int start, end;
+ int len;
start = MIN (self->select_info->selection_anchor,
self->select_info->selection_end);
GdkModifierType state_mask;
GdkEventSequence *sequence;
GdkEvent *event;
- gint min, max, index;
+ int min, max, index;
if (!info || !info->selectable)
{
/* ensure the anchor is opposite index */
if (index == min)
{
- gint tmp = min;
+ int tmp = min;
min = max;
max = tmp;
}
GtkWidget *widget = GTK_WIDGET (self);
GdkEventSequence *sequence;
gdouble x, y;
- gint index;
+ int index;
if (info == NULL || !info->selectable)
return;
if (info->select_words)
{
- gint min, max;
- gint old_min, old_max;
- gint anchor, end;
+ int min, max;
+ int old_min, old_max;
+ int anchor, end;
min = gtk_label_move_backward_word (self, index);
max = gtk_label_move_forward_word (self, index);
{
GtkLabel *self = GTK_LABEL (widget);
GtkLabelSelectionInfo *info = self->select_info;
- gint index;
+ int index;
if (info == NULL)
return;
self->select_info->selection_end) &&
self->text)
{
- gint start, end;
- gint len;
+ int start, end;
+ int len;
char *str;
start = MIN (self->select_info->selection_anchor,
static void
gtk_label_select_region_index (GtkLabel *self,
- gint anchor_index,
- gint end_index)
+ int anchor_index,
+ int end_index)
{
g_return_if_fail (GTK_IS_LABEL (self));
gboolean anchor_changed;
if (self->select_info && self->select_info->selectable)
{
GdkClipboard *clipboard;
- gint s, e;
+ int s, e;
/* Ensure that we treat an ellipsized region like a single
* character with respect to selection.
**/
void
gtk_label_select_region (GtkLabel *self,
- gint start_offset,
- gint end_offset)
+ int start_offset,
+ int end_offset)
{
g_return_if_fail (GTK_IS_LABEL (self));
**/
gboolean
gtk_label_get_selection_bounds (GtkLabel *self,
- gint *start,
- gint *end)
+ int *start,
+ int *end)
{
g_return_val_if_fail (GTK_IS_LABEL (self), FALSE);
}
else
{
- gint start_index, end_index;
- gint start_offset, end_offset;
- gint len;
+ int start_index, end_index;
+ int start_offset, end_offset;
+ int len;
start_index = MIN (self->select_info->selection_anchor,
self->select_info->selection_end);
if (start_offset > end_offset)
{
- gint tmp = start_offset;
+ int tmp = start_offset;
start_offset = end_offset;
end_offset = tmp;
}
**/
void
gtk_label_get_layout_offsets (GtkLabel *self,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
g_return_if_fail (GTK_IS_LABEL (self));
}
-static gint
+static int
gtk_label_move_logically (GtkLabel *self,
- gint start,
- gint count)
+ int start,
+ int count)
{
- gint offset = g_utf8_pointer_to_offset (self->text,
+ int offset = g_utf8_pointer_to_offset (self->text,
self->text + start);
if (self->text)
{
const PangoLogAttr *log_attrs;
- gint n_attrs;
- gint length;
+ int n_attrs;
+ int length;
gtk_label_ensure_layout (self);
return g_utf8_offset_to_pointer (self->text, offset) - self->text;
}
-static gint
+static int
gtk_label_move_visually (GtkLabel *self,
- gint start,
- gint count)
+ int start,
+ int count)
{
- gint index;
+ int index;
index = start;
return index;
}
-static gint
+static int
gtk_label_move_forward_word (GtkLabel *self,
- gint start)
+ int start)
{
- gint new_pos = g_utf8_pointer_to_offset (self->text,
+ int new_pos = g_utf8_pointer_to_offset (self->text,
self->text + start);
- gint length;
+ int length;
length = g_utf8_strlen (self->text, -1);
if (new_pos < length)
{
const PangoLogAttr *log_attrs;
- gint n_attrs;
+ int n_attrs;
gtk_label_ensure_layout (self);
}
-static gint
+static int
gtk_label_move_backward_word (GtkLabel *self,
- gint start)
+ int start)
{
- gint new_pos = g_utf8_pointer_to_offset (self->text,
+ int new_pos = g_utf8_pointer_to_offset (self->text,
self->text + start);
if (new_pos > 0)
{
const PangoLogAttr *log_attrs;
- gint n_attrs;
+ int n_attrs;
gtk_label_ensure_layout (self);
static void
gtk_label_move_cursor (GtkLabel *self,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend_selection)
{
- gint old_pos;
- gint new_pos;
+ int old_pos;
+ int new_pos;
if (self->select_info == NULL)
return;
{
case GTK_MOVEMENT_VISUAL_POSITIONS:
{
- gint end_x, end_y;
- gint anchor_x, anchor_y;
+ int end_x, end_y;
+ int anchor_x, anchor_y;
gboolean end_is_left;
get_better_cursor (self, self->select_info->selection_end, &end_x, &end_y);
{
if (self->text && self->select_info)
{
- gint start, end;
- gint len;
+ int start, end;
+ int len;
GdkClipboard *clipboard;
start = MIN (self->select_info->selection_anchor,
static gboolean
gtk_label_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip)
{
GtkLabel *self = GTK_LABEL (widget);
GtkLabelSelectionInfo *info = self->select_info;
- gint index = -1;
+ int index = -1;
if (info && info->links)
{
tooltip);
}
-gint
+int
_gtk_label_get_cursor_position (GtkLabel *self)
{
if (self->select_info && self->select_info->selectable)
return 0;
}
-gint
+int
_gtk_label_get_selection_bound (GtkLabel *self)
{
if (self->select_info && self->select_info->selectable)
*/
void
gtk_label_set_lines (GtkLabel *self,
- gint lines)
+ int lines)
{
g_return_if_fail (GTK_IS_LABEL (self));
*
* Returns: The number of lines
*/
-gint
+int
gtk_label_get_lines (GtkLabel *self)
{
g_return_val_if_fail (GTK_IS_LABEL (self), -1);
return self->lines;
}
-gint
+int
_gtk_label_get_n_links (GtkLabel *self)
{
if (self->select_info)
const gchar *
_gtk_label_get_link_uri (GtkLabel *self,
- gint idx)
+ int idx)
{
if (self->select_info)
return self->select_info->links[idx].uri;
void
_gtk_label_get_link_extent (GtkLabel *self,
- gint idx,
- gint *start,
- gint *end)
+ int idx,
+ int *start,
+ int *end)
{
if (self->select_info)
{
void
_gtk_label_activate_link (GtkLabel *self,
- gint idx)
+ int idx)
{
if (self->select_info)
{
gboolean
_gtk_label_get_link_visited (GtkLabel *self,
- gint idx)
+ int idx)
{
if (self->select_info)
return self->select_info->links[idx].visited;
gboolean
_gtk_label_get_link_focused (GtkLabel *self,
- gint idx)
+ int idx)
{
GtkLabelSelectionInfo *info = self->select_info;
void gtk_label_set_width_chars (GtkLabel *self,
int n_chars);
GDK_AVAILABLE_IN_ALL
-gint gtk_label_get_width_chars (GtkLabel *self);
+int gtk_label_get_width_chars (GtkLabel *self);
GDK_AVAILABLE_IN_ALL
void gtk_label_set_max_width_chars (GtkLabel *self,
int n_chars);
GDK_AVAILABLE_IN_ALL
-gint gtk_label_get_max_width_chars (GtkLabel *self);
+int gtk_label_get_max_width_chars (GtkLabel *self);
GDK_AVAILABLE_IN_ALL
void gtk_label_set_lines (GtkLabel *self,
- gint lines);
+ int lines);
GDK_AVAILABLE_IN_ALL
-gint gtk_label_get_lines (GtkLabel *self);
+int gtk_label_get_lines (GtkLabel *self);
GDK_AVAILABLE_IN_ALL
void gtk_label_set_wrap (GtkLabel *self,
gboolean wrap);
gboolean gtk_label_get_selectable (GtkLabel *self);
GDK_AVAILABLE_IN_ALL
void gtk_label_select_region (GtkLabel *self,
- gint start_offset,
- gint end_offset);
+ int start_offset,
+ int end_offset);
GDK_AVAILABLE_IN_ALL
gboolean gtk_label_get_selection_bounds (GtkLabel *self,
- gint *start,
- gint *end);
+ int *start,
+ int *end);
GDK_AVAILABLE_IN_ALL
PangoLayout *gtk_label_get_layout (GtkLabel *self);
GDK_AVAILABLE_IN_ALL
void gtk_label_get_layout_offsets (GtkLabel *self,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
GDK_AVAILABLE_IN_ALL
void gtk_label_set_single_line_mode (GtkLabel *self,
void _gtk_label_mnemonics_visible_apply_recursively (GtkWidget *widget,
gboolean mnemonics_visible);
-gint _gtk_label_get_cursor_position (GtkLabel *label);
-gint _gtk_label_get_selection_bound (GtkLabel *label);
+int _gtk_label_get_cursor_position (GtkLabel *label);
+int _gtk_label_get_selection_bound (GtkLabel *label);
-gint _gtk_label_get_n_links (GtkLabel *label);
-gint _gtk_label_get_link_at (GtkLabel *label,
- gint pos);
+int _gtk_label_get_n_links (GtkLabel *label);
+int _gtk_label_get_link_at (GtkLabel *label,
+ int pos);
void _gtk_label_activate_link (GtkLabel *label,
- gint idx);
+ int idx);
const gchar *_gtk_label_get_link_uri (GtkLabel *label,
- gint idx);
+ int idx);
void _gtk_label_get_link_extent (GtkLabel *label,
- gint idx,
- gint *start,
- gint *end);
+ int idx,
+ int *start,
+ int *end);
gboolean _gtk_label_get_link_visited (GtkLabel *label,
- gint idx);
+ int idx);
gboolean _gtk_label_get_link_focused (GtkLabel *label,
- gint idx);
+ int idx);
G_END_DECLS
g_slice_free (GtkLevelBarOffset, offset);
}
-static gint
+static int
offset_find_func (gconstpointer data,
gconstpointer user_data)
{
return g_strcmp0 (name, offset->name);
}
-static gint
+static int
offset_sort_func (gconstpointer a,
gconstpointer b)
{
}
#endif
-static gint
+static int
gtk_level_bar_get_num_blocks (GtkLevelBar *self)
{
if (self->bar_mode == GTK_LEVEL_BAR_MODE_CONTINUOUS)
return 1;
else if (self->bar_mode == GTK_LEVEL_BAR_MODE_DISCRETE)
- return MAX (1, (gint) (round (self->max_value) - round (self->min_value)));
+ return MAX (1, (int) (round (self->max_value) - round (self->min_value)));
return 0;
}
-static gint
+static int
gtk_level_bar_get_num_block_nodes (GtkLevelBar *self)
{
if (self->bar_mode == GTK_LEVEL_BAR_MODE_CONTINUOUS)
static void
gtk_level_bar_get_min_block_size (GtkLevelBar *self,
- gint *block_width,
- gint *block_height)
+ int *block_width,
+ int *block_height)
{
guint i, n_blocks;
- gint width, height;
+ int width, height;
*block_width = *block_height = 0;
n_blocks = gtk_level_bar_get_num_block_nodes (self);
}
else
{
- gint num_blocks, i;
+ int num_blocks, i;
num_blocks = gtk_level_bar_get_num_blocks (self);
{
GtkWidget *widget = GTK_WIDGET (gizmo);
GtkLevelBar *self = GTK_LEVEL_BAR (gtk_widget_get_parent (widget));
- gint num_blocks, size;
- gint block_width, block_height;
+ int num_blocks, size;
+ int block_width, block_height;
num_blocks = gtk_level_bar_get_num_blocks (self);
gtk_level_bar_get_min_block_size (self, &block_width, &block_height);
if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
{
- block_area.width = (gint) floor (block_area.width * fill_percentage);
+ block_area.width = (int) floor (block_area.width * fill_percentage);
block_area.width = MAX (block_area.width, block_min);
if (inverted)
}
else
{
- block_area.height = (gint) floor (block_area.height * fill_percentage);
+ block_area.height = (int) floor (block_area.height * fill_percentage);
block_area.height = MAX (block_area.height, block_min);
if (inverted)
int baseline)
{
GtkAllocation block_area;
- gint num_blocks, i;
- gint block_width, block_height;
+ int num_blocks, i;
+ int block_width, block_height;
gtk_level_bar_get_min_block_size (self, &block_width, &block_height);
num_blocks = gtk_level_bar_get_num_blocks (self);
if (self->orientation == GTK_ORIENTATION_HORIZONTAL)
{
- block_width = MAX (block_width, (gint) floor (width / num_blocks));
+ block_width = MAX (block_width, (int) floor (width / num_blocks));
block_height = height;
}
else
{
block_width = width;
- block_height = MAX (block_height, (gint) floor (height / num_blocks));
+ block_height = MAX (block_height, (int) floor (height / num_blocks));
}
block_area.x = 0;
const gchar *value_class = NULL;
GtkLevelBarOffset *offset, *prev_offset;
GList *l;
- gint num_filled, num_blocks, i;
+ int num_filled, num_blocks, i;
gboolean inverted;
value = gtk_level_bar_get_value (self);
if (self->bar_mode == GTK_LEVEL_BAR_MODE_CONTINUOUS)
num_filled = 1;
else
- num_filled = MIN (num_blocks, (gint) round (self->cur_value) - (gint) round (self->min_value));
+ num_filled = MIN (num_blocks, (int) round (self->cur_value) - (int) round (self->min_value));
for (i = 0; i < num_filled; i++)
{
gtk_level_bar_finalize (GObject *obj)
{
GtkLevelBar *self = GTK_LEVEL_BAR (obj);
- gint i;
+ int i;
g_list_free_full (self->offsets, (GDestroyNotify) gtk_level_bar_offset_free);
const char *action_name,
GVariant *parameters);
static gboolean gtk_link_button_query_tooltip_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data);
static gboolean
gtk_link_button_query_tooltip_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
void (*toggle_cursor_row) (GtkListBox *box);
void (*move_cursor) (GtkListBox *box,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
void (*selected_rows_changed) (GtkListBox *box);
GSequenceIter *iter;
GtkWidget *header;
GtkActionHelper *action_helper;
- gint y;
- gint height;
+ int y;
+ int height;
guint visible :1;
guint selected :1;
guint activatable :1;
guint keyval,
GdkModifierType modmask,
GtkMovementStep step,
- gint count);
+ int count);
static void gtk_list_box_update_cursor (GtkListBox *box,
GtkListBoxRow *row,
gboolean grab_focus);
static void gtk_list_box_toggle_cursor_row (GtkListBox *box);
static void gtk_list_box_move_cursor (GtkListBox *box,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
static void gtk_list_box_parent_cb (GObject *object,
*/
GtkListBoxRow *
gtk_list_box_get_row_at_index (GtkListBox *box,
- gint index_)
+ int index_)
{
GSequenceIter *iter;
*/
GtkListBoxRow *
gtk_list_box_get_row_at_y (GtkListBox *box,
- gint y)
+ int y)
{
GSequenceIter *iter;
gtk_widget_queue_resize (GTK_WIDGET (box));
}
-static gint
+static int
do_sort (GtkListBoxRow *a,
GtkListBoxRow *b,
GtkListBox *box)
guint keyval,
GdkModifierType modmask,
GtkMovementStep step,
- gint count)
+ int count)
{
gtk_widget_class_add_binding_signal (widget_class,
keyval, modmask,
GtkListBoxRow *row)
{
GtkWidget *header;
- gint y, height;
+ int y, height;
graphene_rect_t rect;
if (!box->adjustment)
static void
list_box_add_visible_rows (GtkListBox *box,
- gint n)
+ int n)
{
int was_zero;
iter = g_sequence_iter_next (iter))
{
GtkListBoxRow *row;
- gint row_min;
- gint row_nat;
+ int row_min;
+ int row_nat;
row = g_sequence_get (iter);
iter = g_sequence_iter_next (iter))
{
GtkListBoxRow *row;
- gint row_min = 0;
+ int row_min = 0;
row = g_sequence_get (iter);
if (!row_is_visible (row))
void
gtk_list_box_insert (GtkListBox *box,
GtkWidget *child,
- gint position)
+ int position)
{
GtkListBoxRow *row;
GSequenceIter *prev = NULL;
static void
gtk_list_box_move_cursor (GtkListBox *box,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify)
{
GtkListBoxRow *row;
- gint page_size;
+ int page_size;
GSequenceIter *iter;
- gint start_y;
- gint end_y;
+ int start_y;
+ int end_y;
int height;
row = NULL;
case GTK_MOVEMENT_DISPLAY_LINES:
if (box->cursor_row != NULL)
{
- gint i = count;
+ int i = count;
iter = ROW_PRIV (box->cursor_row)->iter;
*
* Returns: the index of the @row, or -1 if the @row is not in a listbox
*/
-gint
+int
gtk_list_box_row_get_index (GtkListBoxRow *row)
{
GtkListBoxRowPrivate *priv = ROW_PRIV (row);
* Returns: < 0 if @row1 should be before @row2, 0 if they are
* equal and > 0 otherwise
*/
-typedef gint (*GtkListBoxSortFunc) (GtkListBoxRow *row1,
- GtkListBoxRow *row2,
- gpointer user_data);
+typedef int (*GtkListBoxSortFunc) (GtkListBoxRow *row1,
+ GtkListBoxRow *row2,
+ gpointer user_data);
/**
* GtkListBoxUpdateHeaderFunc:
void gtk_list_box_row_set_header (GtkListBoxRow *row,
GtkWidget *header);
GDK_AVAILABLE_IN_ALL
-gint gtk_list_box_row_get_index (GtkListBoxRow *row);
+int gtk_list_box_row_get_index (GtkListBoxRow *row);
GDK_AVAILABLE_IN_ALL
void gtk_list_box_row_changed (GtkListBoxRow *row);
GDK_AVAILABLE_IN_ALL
void gtk_list_box_insert (GtkListBox *box,
GtkWidget *child,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_list_box_remove (GtkListBox *box,
GtkWidget *child);
GtkListBoxRow* gtk_list_box_get_selected_row (GtkListBox *box);
GDK_AVAILABLE_IN_ALL
GtkListBoxRow* gtk_list_box_get_row_at_index (GtkListBox *box,
- gint index_);
+ int index_);
GDK_AVAILABLE_IN_ALL
GtkListBoxRow* gtk_list_box_get_row_at_y (GtkListBox *box,
- gint y);
+ int y);
GDK_AVAILABLE_IN_ALL
void gtk_list_box_select_row (GtkListBox *box,
GtkListBoxRow *row);
* GtkListStore *list_store;
* GtkTreePath *path;
* GtkTreeIter iter;
- * gint i;
+ * int i;
*
* list_store = gtk_list_store_new (N_COLUMNS,
* G_TYPE_STRING,
GList *sort_list;
GType *column_headers;
- gint stamp;
- gint n_columns;
- gint sort_column_id;
- gint length;
+ int stamp;
+ int n_columns;
+ int sort_column_id;
+ int length;
GtkSortType order;
static void gtk_list_store_buildable_init (GtkBuildableIface *iface);
static void gtk_list_store_finalize (GObject *object);
static GtkTreeModelFlags gtk_list_store_get_flags (GtkTreeModel *tree_model);
-static gint gtk_list_store_get_n_columns (GtkTreeModel *tree_model);
+static int gtk_list_store_get_n_columns (GtkTreeModel *tree_model);
static GType gtk_list_store_get_column_type (GtkTreeModel *tree_model,
- gint index);
+ int index);
static gboolean gtk_list_store_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreeIter *iter);
static void gtk_list_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
static gboolean gtk_list_store_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreeIter *parent);
static gboolean gtk_list_store_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gint gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
+static int gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gboolean gtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
static gboolean gtk_list_store_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
static void gtk_list_store_set_n_columns (GtkListStore *list_store,
- gint n_columns);
+ int n_columns);
static void gtk_list_store_set_column_type (GtkListStore *list_store,
- gint column,
+ int column,
GType type);
static void gtk_list_store_increment_stamp (GtkListStore *list_store);
static void gtk_list_store_sort (GtkListStore *list_store);
static void gtk_list_store_sort_iter_changed (GtkListStore *list_store,
GtkTreeIter *iter,
- gint column);
+ int column);
static gboolean gtk_list_store_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order);
static void gtk_list_store_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order);
static void gtk_list_store_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy);
* Returns: a new #GtkListStore
*/
GtkListStore *
-gtk_list_store_new (gint n_columns,
+gtk_list_store_new (int n_columns,
...)
{
GtkListStore *retval;
va_list args;
- gint i;
+ int i;
g_return_val_if_fail (n_columns > 0, NULL);
* Returns: (transfer full): a new #GtkListStore
**/
GtkListStore *
-gtk_list_store_newv (gint n_columns,
+gtk_list_store_newv (int n_columns,
GType *types)
{
GtkListStore *retval;
- gint i;
+ int i;
g_return_val_if_fail (n_columns > 0, NULL);
**/
void
gtk_list_store_set_column_types (GtkListStore *list_store,
- gint n_columns,
+ int n_columns,
GType *types)
{
GtkListStorePrivate *priv;
- gint i;
+ int i;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
static void
gtk_list_store_set_n_columns (GtkListStore *list_store,
- gint n_columns)
+ int n_columns)
{
GtkListStorePrivate *priv = list_store->priv;
int i;
static void
gtk_list_store_set_column_type (GtkListStore *list_store,
- gint column,
+ int column,
GType type)
{
GtkListStorePrivate *priv = list_store->priv;
return GTK_TREE_MODEL_ITERS_PERSIST | GTK_TREE_MODEL_LIST_ONLY;
}
-static gint
+static int
gtk_list_store_get_n_columns (GtkTreeModel *tree_model)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
static GType
gtk_list_store_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ int index)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
GtkListStorePrivate *priv = list_store->priv;
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
GtkListStorePrivate *priv = list_store->priv;
GSequence *seq;
- gint i;
+ int i;
priv->columns_dirty = TRUE;
static void
gtk_list_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
GtkListStorePrivate *priv = list_store->priv;
GtkTreeDataList *list;
- gint tmp_column = column;
+ int tmp_column = column;
g_return_if_fail (column < priv->n_columns);
g_return_if_fail (iter_is_valid (iter, list_store));
return FALSE;
}
-static gint
+static int
gtk_list_store_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
gtk_list_store_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
GtkListStore *list_store = GTK_LIST_STORE (tree_model);
GtkListStorePrivate *priv = list_store->priv;
static gboolean
gtk_list_store_real_set_value (GtkListStore *list_store,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value,
gboolean sort)
{
GtkListStorePrivate *priv = list_store->priv;
GtkTreeDataList *list;
GtkTreeDataList *prev;
- gint old_column = column;
+ int old_column = column;
GValue real_value = G_VALUE_INIT;
gboolean converted = FALSE;
gboolean retval = FALSE;
void
gtk_list_store_set_value (GtkListStore *list_store,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkListStorePrivate *priv;
GtkTreeIter *iter,
gboolean *emit_signal,
gboolean *maybe_need_sort,
- gint *columns,
+ int *columns,
GValue *values,
- gint n_values)
+ int n_values)
{
GtkListStorePrivate *priv = list_store->priv;
- gint i;
+ int i;
GtkTreeIterCompareFunc func = NULL;
func = gtk_list_store_get_compare_func (list_store);
va_list var_args)
{
GtkListStorePrivate *priv = list_store->priv;
- gint column;
+ int column;
GtkTreeIterCompareFunc func = NULL;
- column = va_arg (var_args, gint);
+ column = va_arg (var_args, int);
func = gtk_list_store_get_compare_func (list_store);
if (func != _gtk_tree_data_list_compare_func)
g_value_unset (&value);
- column = va_arg (var_args, gint);
+ column = va_arg (var_args, int);
}
}
void
gtk_list_store_set_valuesv (GtkListStore *list_store,
GtkTreeIter *iter,
- gint *columns,
+ int *columns,
GValue *values,
- gint n_values)
+ int n_values)
{
GtkListStorePrivate *priv;
gboolean emit_signal = FALSE;
void
gtk_list_store_insert (GtkListStore *list_store,
GtkTreeIter *iter,
- gint position)
+ int position)
{
GtkListStorePrivate *priv;
GtkTreePath *path;
GSequence *seq;
GSequenceIter *ptr;
- gint length;
+ int length;
g_return_if_fail (GTK_IS_LIST_STORE (list_store));
g_return_if_fail (iter != NULL);
GtkTreeDataList *copy_prev = NULL;
GtkTreeDataList *copy_iter = NULL;
GtkTreePath *path;
- gint col;
+ int col;
col = 0;
while (dl)
GtkTreePath *dest_path,
const GValue *value)
{
- gint *indices;
+ int *indices;
GtkTreeModel *src_model = NULL;
GtkTreePath *src_path = NULL;
gboolean retval = FALSE;
/* Sorting and reordering */
/* Reordering */
-static gint
+static int
gtk_list_store_reorder_func (GSequenceIter *a,
GSequenceIter *b,
gpointer user_data)
{
GHashTable *new_positions = user_data;
- gint apos = GPOINTER_TO_INT (g_hash_table_lookup (new_positions, a));
- gint bpos = GPOINTER_TO_INT (g_hash_table_lookup (new_positions, b));
+ int apos = GPOINTER_TO_INT (g_hash_table_lookup (new_positions, a));
+ int bpos = GPOINTER_TO_INT (g_hash_table_lookup (new_positions, b));
if (apos < bpos)
return -1;
**/
void
gtk_list_store_reorder (GtkListStore *store,
- gint *new_order)
+ int *new_order)
{
GtkListStorePrivate *priv;
- gint i;
+ int i;
GtkTreePath *path;
GHashTable *new_positions;
GSequenceIter *ptr;
- gint *order;
+ int *order;
g_return_if_fail (GTK_IS_LIST_STORE (store));
g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store));
priv = store->priv;
- order = g_new (gint, g_sequence_get_length (priv->seq));
+ order = g_new (int, g_sequence_get_length (priv->seq));
for (i = 0; i < g_sequence_get_length (priv->seq); i++)
order[new_order[i]] = i;
{
GtkListStorePrivate *priv;
GHashTable *old_positions;
- gint *order;
+ int *order;
GtkTreePath *path;
g_return_if_fail (GTK_IS_LIST_STORE (store));
static void
gtk_list_store_move_to (GtkListStore *store,
GtkTreeIter *iter,
- gint new_pos)
+ int new_pos)
{
GtkListStorePrivate *priv = store->priv;
GHashTable *old_positions;
GtkTreePath *path;
- gint *order;
+ int *order;
old_positions = save_positions (priv->seq);
GtkTreeIter *iter,
GtkTreeIter *position)
{
- gint pos;
+ int pos;
g_return_if_fail (GTK_IS_LIST_STORE (store));
g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store));
GtkTreeIter *iter,
GtkTreeIter *position)
{
- gint pos;
+ int pos;
g_return_if_fail (GTK_IS_LIST_STORE (store));
g_return_if_fail (!GTK_LIST_STORE_IS_SORTED (store));
}
/* Sorting */
-static gint
+static int
gtk_list_store_compare_func (GSequenceIter *a,
GSequenceIter *b,
gpointer user_data)
GtkListStorePrivate *priv = list_store->priv;
GtkTreeIter iter_a;
GtkTreeIter iter_b;
- gint retval;
+ int retval;
GtkTreeIterCompareFunc func;
gpointer data;
gtk_list_store_sort (GtkListStore *list_store)
{
GtkListStorePrivate *priv = list_store->priv;
- gint *new_order;
+ int *new_order;
GtkTreePath *path;
GHashTable *old_positions;
static void
gtk_list_store_sort_iter_changed (GtkListStore *list_store,
GtkTreeIter *iter,
- gint column)
+ int column)
{
GtkListStorePrivate *priv = list_store->priv;
if (!iter_is_sorted (list_store, iter))
{
GHashTable *old_positions;
- gint *order;
+ int *order;
old_positions = save_positions (priv->seq);
g_sequence_sort_changed_iter (iter->user_data,
static gboolean
gtk_list_store_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
static void
gtk_list_store_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order)
{
GtkListStore *list_store = GTK_LIST_STORE (sortable);
static void
gtk_list_store_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
void
gtk_list_store_insert_with_values (GtkListStore *list_store,
GtkTreeIter *iter,
- gint position,
+ int position,
...)
{
GtkListStorePrivate *priv;
GSequence *seq;
GSequenceIter *ptr;
GtkTreeIter tmp_iter;
- gint length;
+ int length;
gboolean changed = FALSE;
gboolean maybe_need_sort = FALSE;
va_list var_args;
void
gtk_list_store_insert_with_valuesv (GtkListStore *list_store,
GtkTreeIter *iter,
- gint position,
- gint *columns,
+ int position,
+ int *columns,
GValue *values,
- gint n_values)
+ int n_values)
{
GtkListStorePrivate *priv;
GtkTreePath *path;
GSequence *seq;
GSequenceIter *ptr;
GtkTreeIter tmp_iter;
- gint length;
+ int length;
gboolean changed = FALSE;
gboolean maybe_need_sort = FALSE;
GSList *column_type_names;
GType *column_types;
GValue *values;
- gint *colids;
+ int *colids;
ColInfo **columns;
- gint last_row;
- gint n_columns;
- gint row_column;
+ int last_row;
+ int n_columns;
+ int row_column;
gboolean is_data;
const gchar *domain;
} SubParserData;
if (strcmp (element_name, "col") == 0)
{
- gint id = -1;
+ int id = -1;
const gchar *id_str;
const gchar *msg_context = NULL;
gboolean translatable = FALSE;
GError **error)
{
SubParserData *data = (SubParserData*)user_data;
- gint i;
+ int i;
gchar *string;
ColInfo *info;
}
else if (strcmp (tagname, "data") == 0)
{
- gint n_columns = gtk_list_store_get_n_columns (GTK_TREE_MODEL (buildable));
+ int n_columns = gtk_list_store_get_n_columns (GTK_TREE_MODEL (buildable));
if (n_columns == 0)
g_error ("Cannot append data to an empty model");
data->builder = builder;
data->object = G_OBJECT (buildable);
data->values = g_new0 (GValue, n_columns);
- data->colids = g_new0 (gint, n_columns);
+ data->colids = g_new0 (int, n_columns);
data->columns = g_new0 (ColInfo*, n_columns);
data->column_types = GTK_LIST_STORE (buildable)->priv->column_headers;
data->n_columns = n_columns;
GDK_AVAILABLE_IN_ALL
GType gtk_list_store_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-GtkListStore *gtk_list_store_new (gint n_columns,
+GtkListStore *gtk_list_store_new (int n_columns,
...);
GDK_AVAILABLE_IN_ALL
-GtkListStore *gtk_list_store_newv (gint n_columns,
+GtkListStore *gtk_list_store_newv (int n_columns,
GType *types);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_set_column_types (GtkListStore *list_store,
- gint n_columns,
+ int n_columns,
GType *types);
/* NOTE: use gtk_tree_model_get to get values from a GtkListStore */
GDK_AVAILABLE_IN_ALL
void gtk_list_store_set_value (GtkListStore *list_store,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_set (GtkListStore *list_store,
GDK_AVAILABLE_IN_ALL
void gtk_list_store_set_valuesv (GtkListStore *list_store,
GtkTreeIter *iter,
- gint *columns,
+ int *columns,
GValue *values,
- gint n_values);
+ int n_values);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_set_valist (GtkListStore *list_store,
GtkTreeIter *iter,
GDK_AVAILABLE_IN_ALL
void gtk_list_store_insert (GtkListStore *list_store,
GtkTreeIter *iter,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_insert_before (GtkListStore *list_store,
GtkTreeIter *iter,
GDK_AVAILABLE_IN_ALL
void gtk_list_store_insert_with_values (GtkListStore *list_store,
GtkTreeIter *iter,
- gint position,
+ int position,
...);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_insert_with_valuesv (GtkListStore *list_store,
GtkTreeIter *iter,
- gint position,
- gint *columns,
+ int position,
+ int *columns,
GValue *values,
- gint n_values);
+ int n_values);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_prepend (GtkListStore *list_store,
GtkTreeIter *iter);
GtkTreeIter *iter);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_reorder (GtkListStore *store,
- gint *new_order);
+ int *new_order);
GDK_AVAILABLE_IN_ALL
void gtk_list_store_swap (GtkListStore *store,
GtkTreeIter *a,
{
GdkPaintable *paintable;
gdouble magnification;
- gint x;
- gint y;
+ int x;
+ int y;
gboolean resize;
};
{
GtkMagnifier *magnifier = GTK_MAGNIFIER (widget);
GtkMagnifierPrivate *priv = gtk_magnifier_get_instance_private (magnifier);
- gint size;
+ int size;
if (priv->resize)
{
static GtkWindowGroup *gtk_main_get_window_group (GtkWidget *widget);
-static gint pre_initialized = FALSE;
-static gint gtk_initialized = FALSE;
+static int pre_initialized = FALSE;
+static int gtk_initialized = FALSE;
static GList *current_events = NULL;
typedef struct {
guint required_minor,
guint required_micro)
{
- gint gtk_effective_micro = 100 * GTK_MINOR_VERSION + GTK_MICRO_VERSION;
- gint required_effective_micro = 100 * required_minor + required_micro;
+ int gtk_effective_micro = 100 * GTK_MINOR_VERSION + GTK_MICRO_VERSION;
+ int required_effective_micro = 100 * required_minor + required_micro;
if (required_major > GTK_MAJOR_VERSION)
return "GTK version too old (major mismatch)";
guint
gtk_get_display_debug_flags (GdkDisplay *display)
{
- gint i;
+ int i;
if (display == NULL)
display = gdk_display_get_default ();
gtk_set_display_debug_flags (GdkDisplay *display,
guint flags)
{
- gint i;
+ int i;
for (i = 0; i < N_DEBUG_DISPLAYS; i++)
{
gboolean
gtk_simulate_touchscreen (void)
{
- static gint test_touchscreen;
+ static int test_touchscreen;
if (test_touchscreen == 0)
test_touchscreen = g_getenv ("GTK_TEST_TOUCHSCREEN") != NULL ? 1 : -1;
GdkEvent *event,
GtkWidget *topmost)
{
- gint handled_event = FALSE;
+ int handled_event = FALSE;
GtkWidget *target = widget;
GtkWidgetStack widget_array;
int i;
# BOOLEAN for boolean types (gboolean)
# CHAR for signed char types (gchar)
# UCHAR for unsigned char types (guchar)
-# INT for signed integer types (gint)
+# INT for signed integer types (int)
# UINT for unsigned integer types (guint)
# LONG for signed long integer types (glong)
# ULONG for unsigned long integer types (gulong)
-# ENUM for enumeration types (gint)
+# ENUM for enumeration types (int)
# FLAGS for flag enumeration types (guint)
# FLOAT for single-precision float types (gfloat)
# DOUBLE for double-precision float types (gdouble)
void
gtk_media_stream_error (GtkMediaStream *self,
GQuark domain,
- gint code,
+ int code,
const gchar *format,
...)
{
void
gtk_media_stream_error_valist (GtkMediaStream *self,
GQuark domain,
- gint code,
+ int code,
const gchar *format,
va_list args)
{
GDK_AVAILABLE_IN_ALL
void gtk_media_stream_error (GtkMediaStream *self,
GQuark domain,
- gint code,
+ int code,
const gchar *format,
...) G_GNUC_PRINTF (4, 5);
GDK_AVAILABLE_IN_ALL
void gtk_media_stream_error_valist (GtkMediaStream *self,
GQuark domain,
- gint code,
+ int code,
const gchar *format,
va_list args) G_GNUC_PRINTF (4, 0);
gboolean iconic;
gboolean inline_buttons;
gboolean circular;
- gint depth;
+ int depth;
GtkPopoverMenuFlags flags;
GtkSizeGroup *indicators;
};
typedef struct
{
- gint n_items;
+ int n_items;
gboolean previous_is_iconic;
} MenuData;
gboolean has_separator;
gboolean has_label;
gboolean separator_condition;
- gint n_items_before;
+ int n_items_before;
GtkWidget *child;
n_items_before = data->n_items;
}
static void
-gtk_menu_section_box_remove_func (gint position,
+gtk_menu_section_box_remove_func (int position,
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
static void
gtk_menu_section_box_insert_func (GtkMenuTrackerItem *item,
- gint position,
+ int position,
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
GMenuModel *model,
gboolean with_separators,
gboolean separator_label,
- gint offset,
+ int offset,
const gchar *action_namespace);
static void gtk_menu_tracker_section_free (GtkMenuTrackerSection *section);
static GtkMenuTrackerSection *
gtk_menu_tracker_section_find_model (GtkMenuTrackerSection *section,
gpointer model,
- gint *offset)
+ int *offset)
{
GSList *item;
* have any items in us or if we are completely empty and sync if our
* separator is shown or not.
*/
-static gint
+static int
gtk_menu_tracker_section_sync_separators (GtkMenuTrackerSection *section,
GtkMenuTracker *tracker,
- gint offset,
+ int offset,
gboolean could_have_separator,
GMenuModel *parent_model,
- gint parent_index)
+ int parent_index)
{
gboolean should_have_separator;
- gint n_items = 0;
+ int n_items = 0;
GSList *item;
- gint i = 0;
+ int i = 0;
for (item = section->items; item; item = item->next)
{
GtkMenuTrackerSection *section;
gboolean is_now_visible;
gboolean was_visible;
- gint offset = 0;
+ int offset = 0;
is_now_visible = gtk_menu_tracker_item_get_is_visible (item);
gtk_menu_tracker_section_sync_separators (tracker->toplevel, tracker, 0, FALSE, NULL, 0);
}
-static gint
+static int
gtk_menu_tracker_section_measure (GtkMenuTrackerSection *section)
{
GSList *item;
- gint n_items;
+ int n_items;
if (section == NULL)
return 1;
static void
gtk_menu_tracker_remove_items (GtkMenuTracker *tracker,
GSList **change_point,
- gint offset,
- gint n_items)
+ int offset,
+ int n_items)
{
- gint i;
+ int i;
for (i = 0; i < n_items; i++)
{
GtkMenuTrackerSection *subsection;
- gint n;
+ int n;
subsection = (*change_point)->data;
*change_point = g_slist_delete_link (*change_point, *change_point);
gtk_menu_tracker_add_items (GtkMenuTracker *tracker,
GtkMenuTrackerSection *section,
GSList **change_point,
- gint offset,
+ int offset,
GMenuModel *model,
- gint position,
- gint n_items)
+ int position,
+ int n_items)
{
while (n_items--)
{
static void
gtk_menu_tracker_model_changed (GMenuModel *model,
- gint position,
- gint removed,
- gint added,
+ int position,
+ int removed,
+ int added,
gpointer user_data)
{
GtkMenuTracker *tracker = user_data;
GtkMenuTrackerSection *section;
GSList **change_point;
- gint offset = 0;
- gint i;
+ int offset = 0;
+ int i;
/* First find which section the changed model corresponds to, and the
* position of that section within the overall menu.
GMenuModel *model,
gboolean with_separators,
gboolean separator_label,
- gint offset,
+ int offset,
const gchar *action_namespace)
{
GtkMenuTrackerSection *section;
GtkMenuTrackerItem *
_gtk_menu_tracker_item_new (GtkActionObservable *observable,
GMenuModel *model,
- gint item_index,
+ int item_index,
gboolean mac_os_mode,
const gchar *action_namespace,
gboolean is_separator)
GtkMenuTrackerItem * _gtk_menu_tracker_item_new (GtkActionObservable *observable,
GMenuModel *model,
- gint item_index,
+ int item_index,
gboolean mac_os_mode,
const gchar *action_namespace,
gboolean is_separator);
typedef struct _GtkMenuTracker GtkMenuTracker;
typedef void (* GtkMenuTrackerInsertFunc) (GtkMenuTrackerItem *item,
- gint position,
+ int position,
gpointer user_data);
-typedef void (* GtkMenuTrackerRemoveFunc) (gint position,
+typedef void (* GtkMenuTrackerRemoveFunc) (int position,
gpointer user_data);
gchar **paths = get_module_path();
gchar **path;
gchar **result;
- gint count = 0;
+ int count = 0;
for (path = paths; *path; path++)
count++;
count = 0;
for (path = get_module_path (); *path; path++)
{
- gint use_version, use_host;
+ int use_version, use_host;
for (use_version = TRUE; use_version >= FALSE; use_version--)
for (use_host = TRUE; use_host >= FALSE; use_host--)
gboolean
_gtk_mount_operation_lookup_info (GtkMountOperationLookupContext *context,
GPid pid,
- gint size_pixels,
+ int size_pixels,
gchar **out_name,
gchar **out_command_line,
GdkTexture **out_texture)
struct _GtkMountOperationLookupContext
{
- /* Hash from pid (gint) -> XID (gint)
+ /* Hash from pid (int) -> XID (int)
*
* Note that XIDs are at most 27 bits - however, also note that sizeof(XID) == 8 on
* x86_64 - that's just xlib brokenness. So it's safe to stuff the XID into a pointer.
{
GtkMountOperationLookupContext *context;
Window *mapping;
- gint mapping_length;
- gint n;
+ int mapping_length;
+ int n;
context = g_new0 (GtkMountOperationLookupContext, 1);
&mapping_length);
for (n = 0; n < mapping_length; n++)
{
- gint pid;
+ int pid;
if (!get_cardinal (context->display,
GDK_DISPLAY_XDISPLAY (context->display),
g_hash_table_insert (context->pid_to_window,
GINT_TO_POINTER (pid),
- GINT_TO_POINTER ((gint) mapping[n]));
+ GINT_TO_POINTER ((int) mapping[n]));
}
g_free (mapping);
static GdkTexture *
get_texture_for_window_with_pid (GtkMountOperationLookupContext *context,
GPid pid,
- gint size_pixels)
+ int size_pixels)
{
Window window;
GdkTexture *ret;
if (window != None)
{
- gint width;
- gint height;
+ int width;
+ int height;
guchar *pixdata;
if (read_rgb_icon (context->display,
gboolean
_gtk_mount_operation_lookup_info (GtkMountOperationLookupContext *context,
GPid pid,
- gint size_pixels,
+ int size_pixels,
gchar **out_name,
gchar **out_command_line,
GdkTexture **out_texture)
static void
pw_dialog_got_response (GtkDialog *dialog,
- gint response_id,
+ int response_id,
GtkMountOperation *mount_op)
{
GtkMountOperationPrivate *priv = mount_op->priv;
static void
question_dialog_button_clicked (GtkDialog *dialog,
- gint button_number,
+ int button_number,
GMountOperation *op)
{
GtkMountOperationPrivate *priv;
static void
show_processes_button_clicked (GtkDialog *dialog,
- gint button_number,
+ int button_number,
GMountOperation *op)
{
GtkMountOperationPrivate *priv;
g_object_unref (op);
}
-static gint
+static int
pid_equal (gconstpointer a,
gconstpointer b)
{
GArray *added_indices,
GArray *removed_indices)
{
- gint order;
+ int order;
guint n1, n2;
guint elem_size;
* items as appropriate
*/
current_pids = g_array_new (FALSE, FALSE, sizeof (GPid));
- pid_indices_to_add = g_array_new (FALSE, FALSE, sizeof (gint));
- pid_indices_to_remove = g_array_new (FALSE, FALSE, sizeof (gint));
+ pid_indices_to_add = g_array_new (FALSE, FALSE, sizeof (int));
+ pid_indices_to_remove = g_array_new (FALSE, FALSE, sizeof (int));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter))
{
gdk_event_get_position (event, &x, &y);
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (op->priv->process_tree_view),
- (gint) x,
- (gint) y,
+ (int) x,
+ (int) y,
&path,
NULL,
NULL,
gboolean _gtk_mount_operation_lookup_info (GtkMountOperationLookupContext *context,
GPid pid,
- gint size_pixels,
+ int size_pixels,
gchar **out_name,
gchar **out_command_line,
GdkTexture **out_texture);
guint modal : 1;
/* Run state */
- gint run_response_id;
+ int run_response_id;
GMainLoop *run_loop; /* Non-NULL when in run */
};
{
GObjectClass parent_class;
- void (* response) (GtkNativeDialog *self, gint response_id);
+ void (* response) (GtkNativeDialog *self, int response_id);
/* <private> */
void (* show) (GtkNativeDialog *self);
gboolean (* focus_tab) (GtkNotebook *notebook,
GtkNotebookTab type);
gboolean (* change_current_page) (GtkNotebook *notebook,
- gint offset);
+ int offset);
void (* move_focus_out) (GtkNotebook *notebook,
GtkDirectionType direction);
gboolean (* reorder_tab) (GtkNotebook *notebook,
GtkDirectionType direction,
gboolean move_to_last);
/* More vfuncs */
- gint (* insert_page) (GtkNotebook *notebook,
+ int (* insert_page) (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label,
- gint position);
+ int position);
GtkNotebook * (* create_window) (GtkNotebook *notebook,
GtkWidget *page);
GList *first_tab; /* The first tab visible (for scrolling notebooks) */
GList *focus_tab;
- gint drag_begin_x;
- gint drag_begin_y;
- gint drag_offset_x;
- gint drag_offset_y;
- gint drag_surface_x;
- gint drag_surface_y;
- gint mouse_x;
- gint mouse_y;
- gint pressed_button;
+ int drag_begin_x;
+ int drag_begin_y;
+ int drag_offset_x;
+ int drag_offset_y;
+ int drag_surface_x;
+ int drag_surface_y;
+ int mouse_x;
+ int mouse_y;
+ int pressed_button;
GQuark group;
static gboolean gtk_notebook_focus_tab (GtkNotebook *notebook,
GtkNotebookTab type);
static gboolean gtk_notebook_change_current_page (GtkNotebook *notebook,
- gint offset);
+ int offset);
static void gtk_notebook_move_focus_out (GtkNotebook *notebook,
GtkDirectionType direction_type);
static gboolean gtk_notebook_reorder_tab (GtkNotebook *notebook,
GtkWidget *widget);
/*** GtkNotebook Methods ***/
-static gint gtk_notebook_real_insert_page (GtkNotebook *notebook,
+static int gtk_notebook_real_insert_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label,
- gint position);
+ int position);
static GtkNotebook *gtk_notebook_create_window (GtkNotebook *notebook,
GtkWidget *page);
static void gtk_notebook_measure_tabs (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline);
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline);
static void gtk_notebook_allocate_tabs (GtkGizmo *gizmo,
int width,
int height,
static void gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list);
static void gtk_notebook_update_labels (GtkNotebook *notebook);
-static gint gtk_notebook_timer (GtkNotebook *notebook);
+static int gtk_notebook_timer (GtkNotebook *notebook);
static void gtk_notebook_set_scroll_timer (GtkNotebook *notebook);
-static gint gtk_notebook_page_compare (gconstpointer a,
+static int gtk_notebook_page_compare (gconstpointer a,
gconstpointer b);
static GList* gtk_notebook_find_child (GtkNotebook *notebook,
GtkWidget *child);
static GList * gtk_notebook_search_page (GtkNotebook *notebook,
GList *list,
- gint direction,
+ int direction,
gboolean find_visible);
static void gtk_notebook_child_reordered (GtkNotebook *notebook,
GtkNotebookPage *page);
-static gint gtk_notebook_insert_notebook_page (GtkNotebook *notebook,
- GtkNotebookPage *page,
- int position);
+static int gtk_notebook_insert_notebook_page (GtkNotebook *notebook,
+ GtkNotebookPage *page,
+ int position);
/*** GtkNotebook Size Allocate Functions ***/
static void gtk_notebook_pages_allocate (GtkNotebook *notebook,
static void gtk_notebook_calc_tabs (GtkNotebook *notebook,
GList *start,
GList **end,
- gint *tab_space,
+ int *tab_space,
guint direction);
/*** GtkNotebook Page Switch Methods ***/
/*** GtkNotebook Page Switch Functions ***/
static void gtk_notebook_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page);
-static gint gtk_notebook_page_select (GtkNotebook *notebook,
+static int gtk_notebook_page_select (GtkNotebook *notebook,
gboolean move_focus);
static void gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
GList *new_child);
static gboolean
gtk_notebook_change_current_page (GtkNotebook *notebook,
- gint offset)
+ int offset)
{
GList *current = NULL;
g_object_unref (notebook);
}
-static gint
+static int
reorder_tab (GtkNotebook *notebook, GList *position, GList *tab)
{
GList *elem;
{
GtkDirectionType effective_direction = get_effective_direction (notebook, direction_type);
GList *last, *child, *element;
- gint page_num, old_page_num, i;
+ int page_num, old_page_num, i;
if (!gtk_widget_is_focus (GTK_WIDGET (notebook)) || !notebook->show_tabs)
return FALSE;
static void
gtk_notebook_distribute_arrow_width (GtkNotebook *notebook,
GtkPackType type,
- gint size,
- gint *out_left,
- gint *out_right)
+ int size,
+ int *out_left,
+ int *out_right)
{
GtkRequestedSize sizes[2];
gtk_notebook_measure_arrows (GtkNotebook *notebook,
GtkPackType type,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
- gint child1_min, child1_nat;
- gint child2_min, child2_nat;
+ int child1_min, child1_nat;
+ int child2_min, child2_nat;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
}
else
{
- gint child1_size, child2_size;
+ int child1_size, child2_size;
if (for_size > -1)
gtk_notebook_distribute_arrow_width (notebook, type, for_size, &child1_size, &child2_size);
gtk_notebook_get_preferred_tabs_size (GtkNotebook *notebook,
GtkRequisition *requisition)
{
- gint tab_width = 0;
- gint tab_height = 0;
- gint tab_max = 0;
+ int tab_width = 0;
+ int tab_height = 0;
+ int tab_max = 0;
guint vis_pages = 0;
GList *children;
GtkNotebookPage *page;
if (notebook->scrollable)
{
- gint arrow_height, unused;
+ int arrow_height, unused;
gtk_notebook_measure_arrows (notebook,
GTK_PACK_START,
GTK_ORIENTATION_VERTICAL,
if (notebook->scrollable)
{
- gint start_arrow_width, end_arrow_width, unused;
+ int start_arrow_width, end_arrow_width, unused;
gtk_notebook_measure_arrows (notebook,
GTK_PACK_START,
if (notebook->scrollable)
{
- gint arrow_width, unused;
+ int arrow_width, unused;
gtk_notebook_measure_arrows (notebook,
GTK_PACK_START,
GTK_ORIENTATION_HORIZONTAL,
if (notebook->scrollable)
{
- gint start_arrow_height, end_arrow_height, unused;
+ int start_arrow_height, end_arrow_height, unused;
gtk_notebook_measure_arrows (notebook,
GTK_PACK_START,
static void
gtk_notebook_measure_tabs (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkWidget *widget = gtk_widget_get_parent (GTK_WIDGET (gizmo));
GtkNotebook *notebook = GTK_NOTEBOOK (gtk_widget_get_parent (widget));
static GtkNotebookArrow
gtk_notebook_get_arrow (GtkNotebook *notebook,
- gint x,
- gint y)
+ int x,
+ int y)
{
- gint i;
+ int i;
if (gtk_notebook_show_arrows (notebook))
{
static gboolean
gtk_notebook_arrow_button_press (GtkNotebook *notebook,
GtkNotebookArrow arrow,
- gint button)
+ int button)
{
GtkWidget *widget = GTK_WIDGET (notebook);
gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
GList *children, *last_child;
GtkNotebookPage *page;
gboolean is_rtl;
- gint x, y;
+ int x, y;
x = notebook->mouse_x;
y = notebook->mouse_y;
{
if (notebook->operation == DRAG_OPERATION_REORDER)
{
- gint old_page_num, page_num, i;
+ int old_page_num, page_num, i;
GList *element;
element = get_drop_position (notebook);
{
GtkWidget *widget = GTK_WIDGET (notebook);
graphene_rect_t area;
- gint width, height;
+ int width, height;
gboolean is_rtl;
if (!notebook->scrollable)
if (notebook->tab_pos == GTK_POS_TOP ||
notebook->tab_pos == GTK_POS_BOTTOM)
{
- gint x = notebook->mouse_x;
+ int x = notebook->mouse_x;
is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
}
else
{
- gint y = notebook->mouse_y;
+ int y = notebook->mouse_y;
if (y > height - SCROLL_THRESHOLD)
return POINTER_AFTER;
static gboolean
check_threshold (GtkNotebook *notebook,
- gint current_x,
- gint current_y)
+ int current_x,
+ int current_y)
{
- gint dnd_threshold;
+ int dnd_threshold;
graphene_rect_t rectangle;
GtkSettings *settings;
static void
update_arrow_state (GtkNotebook *notebook)
{
- gint i;
+ int i;
gboolean is_rtl, left;
is_rtl = gtk_widget_get_direction (GTK_WIDGET (notebook)) == GTK_TEXT_DIR_RTL;
gboolean arrow[4];
const char *up_icon_name;
const char *down_icon_name;
- gint i;
+ int i;
if (notebook->tab_pos == GTK_POS_LEFT ||
notebook->tab_pos == GTK_POS_RIGHT)
GtkWidget *tab_label, *menu_label;
gboolean tab_expand, tab_fill, reorderable, detachable;
GList *element;
- gint page_num;
+ int page_num;
GtkNotebookPage *page;
menu_label = gtk_notebook_get_menu_label (from, child);
{
GtkNotebookPage *page;
GList *children, *list;
- gint page_num = 0;
+ int page_num = 0;
children = notebook->children;
while (children)
static gboolean
focus_tabs_move (GtkNotebook *notebook,
GtkDirectionType direction,
- gint search_direction)
+ int search_direction)
{
GList *new_page;
static gboolean
focus_action_in (GtkNotebook *notebook,
- gint action,
+ int action,
GtkDirectionType direction)
{
if (notebook->action_widget[action] &&
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkWidget *old_focus_child;
GtkDirectionType effective_direction;
- gint first_action;
- gint last_action;
+ int first_action;
+ int last_action;
gboolean widget_is_focus;
static void
measure_tab (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkNotebook *notebook = g_object_get_data (G_OBJECT (gizmo), "notebook");
GList *l;
g_clear_handle_id (¬ebook->switch_page_timer, g_source_remove);
}
-static gint
+static int
gtk_notebook_insert_notebook_page (GtkNotebook *notebook,
GtkNotebookPage *page,
int position)
{
- gint nchildren;
+ int nchildren;
GList *list;
GtkWidget *sibling;
GtkEventController *controller;
return gtk_notebook_page_num (notebook, page->child);
}
-static gint
+static int
gtk_notebook_real_insert_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label,
- gint position)
+ int position)
{
GtkNotebookPage *page;
int ret;
}
}
-static gint
+static int
gtk_notebook_page_compare (gconstpointer a,
gconstpointer b)
{
{
GtkNotebookPage *page;
GList * next_list;
- gint need_resize = FALSE;
+ int need_resize = FALSE;
GtkWidget *tab_label;
gboolean destroying;
int position;
GtkNotebookPage *page;
GList *list;
char string[32];
- gint page_num = 1;
+ int page_num = 1;
if (!notebook->show_tabs && !notebook->menu)
return;
static GList *
gtk_notebook_search_page (GtkNotebook *notebook,
GList *list,
- gint direction,
+ int direction,
gboolean find_visible)
{
GtkNotebookPage *page = NULL;
GtkNotebookPage *page;
GList *children;
gboolean showarrow;
- gint step = STEP_PREV;
+ int step = STEP_PREV;
gboolean is_rtl;
GtkPositionType tab_pos;
guint i;
GtkAllocation *allocation)
{
GtkAllocation arrow_allocation;
- gint size1, size2, min, nat;
+ int size1, size2, min, nat;
guint i, ii;
switch (notebook->tab_pos)
int notebook_height,
gboolean *show_arrows,
GtkAllocation *tabs_allocation,
- gint *tab_space)
+ int *tab_space)
{
GList *children;
GtkPositionType tab_pos = get_effective_tab_pos (notebook);
gtk_notebook_calculate_shown_tabs (GtkNotebook *notebook,
gboolean show_arrows,
const GtkAllocation *tabs_allocation,
- gint tab_space,
+ int tab_space,
GList **last_child,
- gint *n,
- gint *remaining_space)
+ int *n,
+ int *remaining_space)
{
GList *children;
GtkNotebookPage *page;
else /* !show_arrows */
{
GtkOrientation tab_expand_orientation;
- gint c = 0;
+ int c = 0;
*n = 0;
if (notebook->tab_pos == GTK_POS_TOP || notebook->tab_pos == GTK_POS_BOTTOM)
static gboolean
get_allocate_at_bottom (GtkWidget *widget,
- gint search_direction)
+ int search_direction)
{
gboolean is_rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
GtkPositionType tab_pos = get_effective_tab_pos (GTK_NOTEBOOK (widget));
GList **children,
GList *last_child,
gboolean showarrow,
- gint direction,
- gint *remaining_space,
- gint *expanded_tabs,
+ int direction,
+ int *remaining_space,
+ int *expanded_tabs,
const GtkAllocation *allocation)
{
GtkWidget *widget;
GtkNotebookPage *page;
gboolean allocate_at_bottom;
- gint tab_extra_space;
+ int tab_extra_space;
GtkPositionType tab_pos;
- gint left_x, right_x, top_y, bottom_y, anchor;
+ int left_x, right_x, top_y, bottom_y, anchor;
gboolean gap_left, packing_changed;
GtkAllocation child_allocation;
GtkOrientation tab_expand_orientation;
GList *last_child = NULL;
gboolean showarrow = FALSE;
GtkAllocation tabs_allocation;
- gint tab_space, remaining_space;
- gint expanded_tabs;
+ int tab_space, remaining_space;
+ int expanded_tabs;
if (!notebook->show_tabs || !gtk_notebook_has_current_page (notebook))
return;
gtk_notebook_calc_tabs (GtkNotebook *notebook,
GList *start,
GList **end,
- gint *tab_space,
+ int *tab_space,
guint direction)
{
GtkNotebookPage *page = NULL;
page_num);
}
-static gint
+static int
gtk_notebook_page_select (GtkNotebook *notebook,
gboolean move_focus)
{
* Returns: the index (starting from 0) of the appended
* page in the notebook, or -1 if function fails
*/
-gint
+int
gtk_notebook_append_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label)
* Returns: the index (starting from 0) of the appended
* page in the notebook, or -1 if function fails
*/
-gint
+int
gtk_notebook_append_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
* Returns: the index (starting from 0) of the prepended
* page in the notebook, or -1 if function fails
*/
-gint
+int
gtk_notebook_prepend_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label)
* Returns: the index (starting from 0) of the prepended
* page in the notebook, or -1 if function fails
*/
-gint
+int
gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
* Returns: the index (starting from 0) of the inserted
* page in the notebook, or -1 if function fails
*/
-gint
+int
gtk_notebook_insert_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
- gint position)
+ int position)
{
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
g_return_val_if_fail (GTK_IS_WIDGET (child), -1);
}
-static gint
+static int
gtk_notebook_page_compare_tab (gconstpointer a,
gconstpointer b)
{
* Returns: the index (starting from 0) of the inserted
* page in the notebook
*/
-gint
+int
gtk_notebook_insert_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label,
- gint position)
+ int position)
{
GtkNotebookClass *class;
*/
void
gtk_notebook_remove_page (GtkNotebook *notebook,
- gint page_num)
+ int page_num)
{
GList *list = NULL;
* page in the notebook. If the notebook has no pages,
* then -1 will be returned.
*/
-gint
+int
gtk_notebook_get_current_page (GtkNotebook *notebook)
{
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
*/
GtkWidget*
gtk_notebook_get_nth_page (GtkNotebook *notebook,
- gint page_num)
+ int page_num)
{
GtkNotebookPage *page;
GList *list;
*
* Returns: the number of pages in the notebook
*/
-gint
+int
gtk_notebook_get_n_pages (GtkNotebook *notebook)
{
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), 0);
* Returns: the index of the page containing @child, or
* -1 if @child is not in the notebook
*/
-gint
+int
gtk_notebook_page_num (GtkNotebook *notebook,
GtkWidget *child)
{
GList *children;
- gint num;
+ int num;
g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
*/
void
gtk_notebook_set_current_page (GtkNotebook *notebook,
- gint page_num)
+ int page_num)
{
GList *list;
{
GtkNotebookPage *page;
GList *children;
- gint i;
+ int i;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
GTK_STYLE_CLASS_TOP,
GTK_STYLE_CLASS_BOTTOM
};
- gint i;
+ int i;
tab_pos = get_effective_tab_pos (notebook);
void
gtk_notebook_reorder_child (GtkNotebook *notebook,
GtkWidget *child,
- gint position)
+ int position)
{
GList *list, *new_list;
GtkNotebookPage *page;
- gint old_pos;
- gint max_pos;
- gint i;
+ int old_pos;
+ int max_pos;
+ int i;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
g_return_if_fail (GTK_IS_WIDGET (child));
GDK_AVAILABLE_IN_ALL
GtkWidget * gtk_notebook_new (void);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_append_page (GtkNotebook *notebook,
+int gtk_notebook_append_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_append_page_menu (GtkNotebook *notebook,
+int gtk_notebook_append_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_prepend_page (GtkNotebook *notebook,
+int gtk_notebook_prepend_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
+int gtk_notebook_prepend_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_insert_page (GtkNotebook *notebook,
+int gtk_notebook_insert_page (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_insert_page_menu (GtkNotebook *notebook,
+int gtk_notebook_insert_page_menu (GtkNotebook *notebook,
GtkWidget *child,
GtkWidget *tab_label,
GtkWidget *menu_label,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_notebook_remove_page (GtkNotebook *notebook,
- gint page_num);
+ int page_num);
/***********************************************************
* Tabs drag and drop *
***********************************************************/
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_get_current_page (GtkNotebook *notebook);
+int gtk_notebook_get_current_page (GtkNotebook *notebook);
GDK_AVAILABLE_IN_ALL
GtkWidget* gtk_notebook_get_nth_page (GtkNotebook *notebook,
- gint page_num);
+ int page_num);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_get_n_pages (GtkNotebook *notebook);
+int gtk_notebook_get_n_pages (GtkNotebook *notebook);
GDK_AVAILABLE_IN_ALL
-gint gtk_notebook_page_num (GtkNotebook *notebook,
+int gtk_notebook_page_num (GtkNotebook *notebook,
GtkWidget *child);
GDK_AVAILABLE_IN_ALL
void gtk_notebook_set_current_page (GtkNotebook *notebook,
- gint page_num);
+ int page_num);
GDK_AVAILABLE_IN_ALL
void gtk_notebook_next_page (GtkNotebook *notebook);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_notebook_reorder_child (GtkNotebook *notebook,
GtkWidget *child,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
gboolean gtk_notebook_get_tab_reorderable (GtkNotebook *notebook,
GtkWidget *child);
static const ActionEntryData *
gtk_pad_action_find_match (GtkPadController *controller,
GtkPadActionType type,
- gint index,
- gint mode)
+ int index,
+ int mode)
{
guint i;
if (GDK_IS_WAYLAND_DISPLAY (gdk_device_get_display (pad)))
{
const ActionEntryData *entry;
- gint elem, idx, n_features;
+ int elem, idx, n_features;
for (elem = GTK_PAD_ACTION_BUTTON; elem <= GTK_PAD_ACTION_STRIP; elem++)
{
NULL);
}
-static gint
+static int
entry_compare_func (gconstpointer a,
gconstpointer b)
{
void
gtk_pad_controller_set_action_entries (GtkPadController *controller,
const GtkPadActionEntry *entries,
- gint n_entries)
+ int n_entries)
{
- gint i;
+ int i;
g_return_if_fail (GTK_IS_PAD_CONTROLLER (controller));
g_return_if_fail (entries != NULL);
GDK_AVAILABLE_IN_ALL
void gtk_pad_controller_set_action_entries (GtkPadController *controller,
const GtkPadActionEntry *entries,
- gint n_entries);
+ int n_entries);
GDK_AVAILABLE_IN_ALL
void gtk_pad_controller_set_action (GtkPadController *controller,
GtkPadActionType type,
- gint index,
- gint mode,
+ int index,
+ int mode,
const gchar *label,
const gchar *action_name);
GList *list, *l;
GtkPageSetup *current_page_setup, *page_setup;
GtkPaperSize *paper_size;
- gint i;
+ int i;
g_list_store_remove_all (dialog->page_setup_list);
gchar *val, *p;
struct lconv *locale_data;
const gchar *decimal_point;
- gint decimal_point_len;
+ int decimal_point_len;
locale_data = localeconv ();
decimal_point = locale_data->decimal_point;
static void
custom_paper_dialog_response_cb (GtkDialog *custom_paper_dialog,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GtkPageSetupUnixDialog *dialog = GTK_PAGE_SETUP_UNIX_DIALOG (user_data);
GtkGesture *pan_gesture; /* Used for touch */
GtkGesture *drag_gesture; /* Used for mice */
- gint start_child_size;
- gint drag_pos;
- gint last_allocation;
- gint max_position;
- gint min_position;
- gint original_position;
+ int start_child_size;
+ int drag_pos;
+ int last_allocation;
+ int max_position;
+ int min_position;
+ int original_position;
guint in_recursion : 1;
guint resize_start_child : 1;
static void gtk_paned_css_changed (GtkWidget *widget,
GtkCssStyleChange *change);
static void gtk_paned_calc_position (GtkPaned *paned,
- gint allocation,
- gint start_child_req,
- gint end_child_req);
+ int allocation,
+ int start_child_req,
+ int end_child_req);
static void gtk_paned_set_focus_child (GtkWidget *widget,
GtkWidget *child);
static void gtk_paned_set_saved_focus (GtkPaned *paned,
static void
gtk_paned_compute_position (GtkPaned *paned,
- gint allocation,
- gint start_child_req,
- gint end_child_req,
- gint *min_pos,
- gint *max_pos,
- gint *out_pos)
+ int allocation,
+ int start_child_req,
+ int end_child_req,
+ int *min_pos,
+ int *max_pos,
+ int *out_pos)
{
- gint min, max, pos;
+ int min, max, pos;
min = paned->shrink_start_child ? 0 : start_child_req;
static void
gtk_paned_get_preferred_size_for_orientation (GtkWidget *widget,
- gint size,
- gint *minimum,
- gint *natural)
+ int size,
+ int *minimum,
+ int *natural)
{
GtkPaned *paned = GTK_PANED (widget);
- gint child_min, child_nat;
+ int child_min, child_nat;
*minimum = *natural = 0;
if (paned->start_child && gtk_widget_get_visible (paned->start_child) &&
paned->end_child && gtk_widget_get_visible (paned->end_child))
{
- gint handle_size;
+ int handle_size;
gtk_widget_measure (paned->handle_widget,
paned->orientation,
static void
gtk_paned_get_preferred_size_for_opposite_orientation (GtkWidget *widget,
- gint size,
- gint *minimum,
- gint *natural)
+ int size,
+ int *minimum,
+ int *natural)
{
GtkPaned *paned = GTK_PANED (widget);
- gint for_start_child, for_end_child;
- gint child_min, child_nat;
+ int for_start_child, for_end_child;
+ int child_min, child_nat;
if (size > -1 &&
paned->start_child && gtk_widget_get_visible (paned->start_child) &&
paned->end_child && gtk_widget_get_visible (paned->end_child))
{
- gint start_child_req, end_child_req;
- gint handle_size;
+ int start_child_req, end_child_req;
+ int handle_size;
gtk_widget_measure (paned->handle_widget,
OPPOSITE_ORIENTATION (paned->orientation),
GtkAllocation start_child_allocation;
GtkAllocation end_child_allocation;
GtkAllocation handle_allocation;
- gint handle_size;
+ int handle_size;
gtk_widget_measure (paned->handle_widget,
paned->orientation,
if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
{
- gint start_child_width, end_child_width;
+ int start_child_width, end_child_width;
gtk_widget_measure (paned->start_child, GTK_ORIENTATION_HORIZONTAL,
height,
}
else
{
- gint start_child_height, end_child_height;
+ int start_child_height, end_child_height;
gtk_widget_measure (paned->start_child, GTK_ORIENTATION_VERTICAL,
width,
int xpos,
int ypos)
{
- gint pos;
- gint handle_size;
- gint size;
+ int pos;
+ int handle_size;
+ int size;
if (paned->orientation == GTK_ORIENTATION_HORIZONTAL)
pos = xpos;
*
* Returns: position of the divider
**/
-gint
+int
gtk_paned_get_position (GtkPaned *paned)
{
g_return_val_if_fail (GTK_IS_PANED (paned), 0);
**/
void
gtk_paned_set_position (GtkPaned *paned,
- gint position)
+ int position)
{
g_return_if_fail (GTK_IS_PANED (paned));
static void
gtk_paned_calc_position (GtkPaned *paned,
- gint allocation,
- gint start_child_req,
- gint end_child_req)
+ int allocation,
+ int start_child_req,
+ int end_child_req)
{
- gint old_position;
- gint old_min_position;
- gint old_max_position;
+ int old_position;
+ int old_min_position;
+ int old_max_position;
old_position = paned->start_child_size;
old_min_position = paned->min_position;
{
if (gtk_widget_is_focus (GTK_WIDGET (paned)))
{
- gint old_position;
- gint new_position;
- gint increment;
+ int old_position;
+ int new_position;
+ int increment;
enum {
SINGLE_STEP_SIZE = 1,
gboolean gtk_paned_get_shrink_end_child (GtkPaned *paned);
GDK_AVAILABLE_IN_ALL
-gint gtk_paned_get_position (GtkPaned *paned);
+int gtk_paned_get_position (GtkPaned *paned);
GDK_AVAILABLE_IN_ALL
void gtk_paned_set_position (GtkPaned *paned,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_paned_set_wide_handle (GtkPaned *paned,
PangoLayout *layout)
{
PangoContext *context;
- gint i;
+ int i;
PangoWrapMode mode;
context = pango_layout_get_context (layout);
AtkAttributeSet *
_gtk_pango_get_run_attributes (AtkAttributeSet *attributes,
PangoLayout *layout,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
PangoAttrIterator *iter;
PangoAttrList *attr;
PangoAttrColor *pango_color;
PangoAttrLanguage *pango_lang;
PangoAttrFloat *pango_float;
- gint index, start_index, end_index;
+ int index, start_index, end_index;
gboolean is_next;
glong len;
const gchar *text;
*
* Returns: the new position
*/
-static gint
+static int
_gtk_pango_move_chars (PangoLayout *layout,
- gint offset,
- gint count)
+ int offset,
+ int count)
{
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
attrs = pango_layout_get_log_attrs_readonly (layout, &n_attrs);
*
* Returns: the new position
*/
-static gint
+static int
_gtk_pango_move_words (PangoLayout *layout,
- gint offset,
- gint count)
+ int offset,
+ int count)
{
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
attrs = pango_layout_get_log_attrs_readonly (layout, &n_attrs);
*
* Returns: the new position
*/
-static gint
+static int
_gtk_pango_move_sentences (PangoLayout *layout,
- gint offset,
- gint count)
+ int offset,
+ int count)
{
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
attrs = pango_layout_get_log_attrs_readonly (layout, &n_attrs);
*/
static gboolean
_gtk_pango_is_inside_word (PangoLayout *layout,
- gint offset)
+ int offset)
{
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
attrs = pango_layout_get_log_attrs_readonly (layout, &n_attrs);
*/
static gboolean
_gtk_pango_is_inside_sentence (PangoLayout *layout,
- gint offset)
+ int offset)
{
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
attrs = pango_layout_get_log_attrs_readonly (layout, &n_attrs);
static void
pango_layout_get_line_before (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
PangoLayoutIter *iter;
PangoLayoutLine *line, *prev_line = NULL, *prev_prev_line = NULL;
- gint index, start_index, end_index;
+ int index, start_index, end_index;
const gchar *text;
gboolean found = FALSE;
static void
pango_layout_get_line_at (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
PangoLayoutIter *iter;
PangoLayoutLine *line, *prev_line = NULL;
- gint index, start_index, end_index;
+ int index, start_index, end_index;
const gchar *text;
gboolean found = FALSE;
static void
pango_layout_get_line_after (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
PangoLayoutIter *iter;
PangoLayoutLine *line, *prev_line = NULL;
- gint index, start_index, end_index;
+ int index, start_index, end_index;
const gchar *text;
gboolean found = FALSE;
gchar *
_gtk_pango_get_text_before (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
const gchar *text;
- gint start, end;
+ int start, end;
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
text = pango_layout_get_text (layout);
gchar *
_gtk_pango_get_text_after (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
const gchar *text;
- gint start, end;
+ int start, end;
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
text = pango_layout_get_text (layout);
gchar *
_gtk_pango_get_text_at (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset)
+ int offset,
+ int *start_offset,
+ int *end_offset)
{
const gchar *text;
- gint start, end;
+ int start, end;
const PangoLogAttr *attrs;
- gint n_attrs;
+ int n_attrs;
text = pango_layout_get_text (layout);
AtkAttributeSet *_gtk_pango_get_run_attributes (AtkAttributeSet *attributes,
PangoLayout *layout,
- gint offset,
- gint *start_offset,
- gint *end_offset);
+ int offset,
+ int *start_offset,
+ int *end_offset);
gchar *_gtk_pango_get_text_before (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset);
+ int offset,
+ int *start_offset,
+ int *end_offset);
gchar *_gtk_pango_get_text_at (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset);
+ int offset,
+ int *start_offset,
+ int *end_offset);
gchar *_gtk_pango_get_text_after (PangoLayout *layout,
AtkTextBoundary boundary_type,
- gint offset,
- gint *start_offset,
- gint *end_offset);
+ int offset,
+ int *start_offset,
+ int *end_offset);
PangoAttrList *_gtk_pango_attr_list_merge (PangoAttrList *into,
PangoAttrList *from);
float x_dimension;
float y_dimension;
gchar *display_name = NULL;
- gint i;
+ int i;
/* Find paper size according to its name */
for (i = 0; i < G_N_ELEMENTS (standard_names_offsets); i++)
GtkTextDirection direction;
GtkAllocation child_allocation;
GList *list, *first_button;
- gint width;
- gint allocation_width;
+ int width;
+ int allocation_width;
gboolean need_sliders = TRUE;
- gint up_slider_offset = 0;
- gint down_slider_offset = 0;
+ int up_slider_offset = 0;
+ int down_slider_offset = 0;
GtkRequisition child_requisition;
/* No path is set; we don't have to allocate anything. */
else
{
gboolean reached_end = FALSE;
- gint slider_space = 2 * path_bar->slider_width;
+ int slider_space = 2 * path_bar->slider_width;
if (path_bar->first_scrolled_button)
first_button = path_bar->first_scrolled_button;
GtkAllocation allocation, button_allocation;
GList *list;
GList *down_button = NULL;
- gint space_available;
+ int space_available;
if (gtk_widget_get_child_visible (BUTTON_DATA (path_bar->button_list->data)->button))
{
}
typedef struct {
- gint scale_factor;
+ int scale_factor;
} LoaderData;
static void
on_loader_size_prepared (GdkPixbufLoader *loader,
- gint width,
- gint height,
+ int width,
+ int height,
gpointer user_data)
{
LoaderData *loader_data = user_data;
static GdkPaintable *
load_scalable_with_loader (GFile *file,
- gint scale_factor)
+ int scale_factor)
{
GdkPixbufLoader *loader;
GBytes *bytes;
/* DND */
gboolean dragging_over;
GtkWidget *drag_row;
- gint drag_row_height;
- gint drag_row_x;
- gint drag_row_y;
+ int drag_row_height;
+ int drag_row_x;
+ int drag_row_y;
GtkWidget *row_placeholder;
DropState drop_state;
gboolean *show_unmount,
gboolean *show_eject);
static void on_row_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkSidebarRow *row);
static void on_row_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkSidebarRow *row);
#else
gpointer *cloud_provider_account,
#endif
- const gint index,
+ const int index,
const gchar *tooltip)
{
gboolean show_eject, show_unmount;
add_special_dirs (GtkPlacesSidebar *sidebar)
{
GList *dirs;
- gint index;
+ int index;
dirs = NULL;
for (index = 0; index < G_USER_N_DIRECTORIES; index++)
GList *volumes;
GVolume *volume;
GSList *bookmarks, *sl;
- gint index;
+ int index;
gchar *original_uri, *name, *identifier;
GtkListBoxRow *selected;
gchar *home_uri;
gboolean valid = FALSE;
gchar *uri;
GFile *dest_file;
- gint drag_action;
+ int drag_action;
g_return_val_if_fail (value != NULL, TRUE);
GtkListBoxRow *row;
GtkPlacesSidebarPlaceType place_type;
gchar *drop_target_uri = NULL;
- gint row_index;
- gint row_placeholder_index;
+ int row_index;
+ int row_placeholder_index;
const GValue *value;
sidebar->dragging_over = TRUE;
static void
reorder_bookmarks (GtkPlacesSidebar *sidebar,
GtkSidebarRow *row,
- gint new_position)
+ int new_position)
{
gchar *uri;
GFile *file;
static void
drop_files_as_bookmarks (GtkPlacesSidebar *sidebar,
GSList *files,
- gint position)
+ int position)
{
GSList *l;
double y,
GtkPlacesSidebar *sidebar)
{
- gint target_order_index;
+ int target_order_index;
GtkPlacesSidebarPlaceType target_place_type;
GtkPlacesSidebarSectionType target_section_type;
gchar *target_uri;
update_popover_shadowing (GtkWidget *row,
gboolean shown)
{
- gint count;
+ int count;
count = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "popover-count"));
count = shown ? count + 1 : count - 1;
static void
on_row_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkSidebarRow *row)
if (section_type == SECTION_BOOKMARKS)
{
sidebar->drag_row = GTK_WIDGET (row);
- sidebar->drag_row_x = (gint)x;
- sidebar->drag_row_y = (gint)y;
+ sidebar->drag_row_x = (int)x;
+ sidebar->drag_row_y = (int)y;
}
g_object_unref (sidebar);
static void
on_row_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkSidebarRow *row)
popup_menu_cb (GTK_SIDEBAR_ROW (row));
}
-static gint
+static int
list_box_sort_func (GtkListBoxRow *row1,
GtkListBoxRow *row2,
gpointer user_data)
GtkPlacesSidebarSectionType section_type_1, section_type_2;
GtkPlacesSidebarPlaceType place_type_1, place_type_2;
gchar *label_1, *label_2;
- gint index_1, index_2;
- gint retval = 0;
+ int index_1, index_2;
+ int retval = 0;
g_object_get (row1,
"label", &label_1,
*/
GFile *
gtk_places_sidebar_get_nth_bookmark (GtkPlacesSidebar *sidebar,
- gint n)
+ int n)
{
GtkWidget *row;
int k;
GListModel * gtk_places_sidebar_get_shortcuts (GtkPlacesSidebar *sidebar);
GFile * gtk_places_sidebar_get_nth_bookmark (GtkPlacesSidebar *sidebar,
- gint n);
+ int n);
void gtk_places_sidebar_set_drop_targets_visible (GtkPlacesSidebar *sidebar,
gboolean visible);
gboolean gtk_places_sidebar_get_show_trash (GtkPlacesSidebar *sidebar);
GtkWidget *child;
gchar **uris;
gsize num_uris;
- gint i;
+ int i;
server_list = server_list_load (view);
}
}
-static gint
+static int
listbox_sort_func (GtkListBoxRow *row1,
GtkListBoxRow *row2,
gpointer user_data)
gchar *path2;
gboolean *is_placeholder1;
gboolean *is_placeholder2;
- gint retval;
+ int retval;
row1_is_network = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row1), "is-network"));
row2_is_network = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row2), "is-network"));
GCancellable *cancellable;
- gint is_network : 1;
+ int is_network : 1;
};
G_DEFINE_TYPE (GtkPlacesViewRow, gtk_places_view_row, GTK_TYPE_LIST_BOX_ROW)
struct _GtkPointerFocus
{
- gint ref_count;
+ int ref_count;
GdkDevice *device;
GdkEventSequence *sequence;
GtkWindow *toplevel;
static void
gtk_popover_get_gap_coords (GtkPopover *popover,
- gint *initial_x_out,
- gint *initial_y_out,
- gint *tip_x_out,
- gint *tip_y_out,
- gint *final_x_out,
- gint *final_y_out)
+ int *initial_x_out,
+ int *initial_y_out,
+ int *tip_x_out,
+ int *tip_y_out,
+ int *final_x_out,
+ int *final_y_out)
{
GtkWidget *widget = GTK_WIDGET (popover);
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GdkRectangle rect = { 0 };
- gint base, tip, tip_pos;
- gint initial_x, initial_y;
- gint tip_x, tip_y;
- gint final_x, final_y;
+ int base, tip, tip_pos;
+ int initial_x, initial_y;
+ int tip_x, tip_y;
+ int final_x, final_y;
GtkPositionType pos;
int border_top, border_right, border_bottom;
int border_radius;
cairo_t *cr)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
- gint initial_x, initial_y;
- gint tip_x, tip_y;
- gint final_x, final_y;
+ int initial_x, initial_y;
+ int tip_x, tip_y;
+ int final_x, final_y;
GtkBorder border;
GtkWidget *parent;
gdk_surface_set_input_region (priv->surface, NULL);
}
-static gint
+static int
get_border_radius (GtkWidget *widget)
{
GtkCssStyle *style;
return round (_gtk_css_number_value_get (style->border->border_top_left_radius, 100));
}
-static gint
+static int
get_minimal_size (GtkPopover *popover,
GtkOrientation orientation)
{
GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
GtkPositionType pos;
- gint minimal_size;
+ int minimal_size;
int tail_gap_width = priv->has_arrow ? TAIL_GAP_WIDTH : 0;
minimal_size = 2 * get_border_radius (GTK_WIDGET (popover));
G_DEFINE_TYPE (GtkPopoverMenuBar, gtk_popover_menu_bar, GTK_TYPE_WIDGET)
static void
-tracker_remove (gint position,
+tracker_remove (int position,
gpointer user_data)
{
GtkWidget *bar = user_data;
static void
tracker_insert (GtkMenuTrackerItem *item,
- gint position,
+ int position,
gpointer user_data)
{
GtkPopoverMenuBar *bar = user_data;
GtkPrintBackend *backend;
gchar *setting;
gchar **backends;
- gint i;
+ int i;
GtkSettings *settings;
GIOExtensionPoint *ep;
static void
password_dialog_response (GtkWidget *dialog,
- gint response_id,
+ int response_id,
GtkPrintBackend *backend)
{
GtkPrintBackendPrivate *priv = backend->priv;
- gint i, auth_info_len;
+ int i, auth_info_len;
if (response_id == GTK_RESPONSE_OK)
gtk_print_backend_set_password (backend, priv->auth_info_required, priv->auth_info, priv->store_auth_info);
GtkWidget *focus = NULL;
GtkWidget *content_area;
gchar *markup;
- gint length;
- gint i;
+ int length;
+ int i;
gchar **ai_required = (gchar **) auth_info_required;
gchar **ai_default = (gchar **) auth_info_default;
gchar **ai_display = (gchar **) auth_info_display;
const gchar *icon);
GDK_AVAILABLE_IN_ALL
gboolean gtk_printer_set_job_count (GtkPrinter *printer,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_printer_set_location (GtkPrinter *printer,
const gchar *location);
guint accepts_ps : 1;
gchar *state_message;
- gint job_count;
+ int job_count;
GtkPrintBackend *backend;
};
*
* Returns: the number of jobs on @printer
*/
-gint
+int
gtk_printer_get_job_count (GtkPrinter *printer)
{
GtkPrinterPrivate *priv = gtk_printer_get_instance_private (printer);
gboolean
gtk_printer_set_job_count (GtkPrinter *printer,
- gint count)
+ int count)
{
GtkPrinterPrivate *priv = gtk_printer_get_instance_private (printer);
* Returns: 0 if the printer match, a negative value if @a < @b,
* or a positive value if @a > @b
*/
-gint
+int
gtk_printer_compare (GtkPrinter *a,
GtkPrinter *b)
{
GDK_AVAILABLE_IN_ALL
const gchar * gtk_printer_get_icon_name (GtkPrinter *printer);
GDK_AVAILABLE_IN_ALL
-gint gtk_printer_get_job_count (GtkPrinter *printer);
+int gtk_printer_get_job_count (GtkPrinter *printer);
GDK_AVAILABLE_IN_ALL
gboolean gtk_printer_is_active (GtkPrinter *printer);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
GtkPageSetup *gtk_printer_get_default_page_size (GtkPrinter *printer);
GDK_AVAILABLE_IN_ALL
-gint gtk_printer_compare (GtkPrinter *a,
+int gtk_printer_compare (GtkPrinter *a,
GtkPrinter *b);
GDK_AVAILABLE_IN_ALL
gboolean gtk_printer_has_details (GtkPrinter *printer);
static void
dialog_response_callback (GtkDialog *dialog,
- gint response_id,
+ int response_id,
GtkPrinterOptionWidget *widget)
{
GtkPrinterOptionWidgetPrivate *priv = widget->priv;
trim_long_filename (const gchar *filename)
{
const gchar *home;
- gint len, offset;
+ int len, offset;
gchar *result;
home = g_get_home_dir ();
GtkPrintPages print_pages;
GtkPageRange *page_ranges;
- gint num_page_ranges;
+ int num_page_ranges;
GtkPageSet page_set;
- gint num_copies;
+ int num_copies;
gdouble scale;
guint number_up;
GtkNumberUpLayout number_up_layout;
*/
GtkPageRange *
gtk_print_job_get_page_ranges (GtkPrintJob *job,
- gint *n_ranges)
+ int *n_ranges)
{
*n_ranges = job->num_page_ranges;
return job->page_ranges;
void
gtk_print_job_set_page_ranges (GtkPrintJob *job,
GtkPageRange *ranges,
- gint n_ranges)
+ int n_ranges)
{
g_free (job->page_ranges);
job->page_ranges = ranges;
*
* Returns: the number of copies
*/
-gint
+int
gtk_print_job_get_num_copies (GtkPrintJob *job)
{
return job->num_copies;
*/
void
gtk_print_job_set_num_copies (GtkPrintJob *job,
- gint num_copies)
+ int num_copies)
{
job->num_copies = num_copies;
}
GtkPrintPages pages);
GDK_AVAILABLE_IN_ALL
GtkPageRange * gtk_print_job_get_page_ranges (GtkPrintJob *job,
- gint *n_ranges);
+ int *n_ranges);
GDK_AVAILABLE_IN_ALL
void gtk_print_job_set_page_ranges (GtkPrintJob *job,
GtkPageRange *ranges,
- gint n_ranges);
+ int n_ranges);
GDK_AVAILABLE_IN_ALL
GtkPageSet gtk_print_job_get_page_set (GtkPrintJob *job);
GDK_AVAILABLE_IN_ALL
void gtk_print_job_set_page_set (GtkPrintJob *job,
GtkPageSet page_set);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_job_get_num_copies (GtkPrintJob *job);
+int gtk_print_job_get_num_copies (GtkPrintJob *job);
GDK_AVAILABLE_IN_ALL
void gtk_print_job_set_num_copies (GtkPrintJob *job,
- gint num_copies);
+ int num_copies);
GDK_AVAILABLE_IN_ALL
gdouble gtk_print_job_get_scale (GtkPrintJob *job);
GDK_AVAILABLE_IN_ALL
GtkPageSetup *default_page_setup;
GtkPrintSettings *print_settings;
gchar *job_name;
- gint nr_of_pages;
- gint nr_of_pages_to_print;
- gint page_position;
- gint current_page;
+ int nr_of_pages;
+ int nr_of_pages_to_print;
+ int page_position;
+ int current_page;
GtkUnit unit;
gchar *export_filename;
guint use_full_page : 1;
GtkPrintPages print_pages;
GtkPageRange *page_ranges;
- gint num_page_ranges;
+ int num_page_ranges;
- gint manual_num_copies;
+ int manual_num_copies;
guint manual_collation : 1;
guint manual_reverse : 1;
guint manual_orientation : 1;
gboolean settings_used = FALSE;
GdkDisplay *display;
GError *error = NULL;
- gint fd;
+ int fd;
gboolean retval;
cairo_surface_destroy (surface);
static void
handle_print_response (GtkWidget *dialog,
- gint response,
+ int response,
gpointer data)
{
GtkPrintUnixDialog *pd = GTK_PRINT_UNIX_DIALOG (dialog);
const unsigned char *data,
unsigned int length)
{
- gint fd = GPOINTER_TO_INT (closure);
+ int fd = GPOINTER_TO_INT (closure);
gssize written;
while (length > 0)
static void
close_preview (void *data)
{
- gint fd = GPOINTER_TO_INT (data);
+ int fd = GPOINTER_TO_INT (data);
close (fd);
}
gchar **target)
{
gchar *filename;
- gint fd;
+ int fd;
GtkPaperSize *paper_size;
gdouble w, h;
cairo_surface_t *surface;
static void
handle_page_setup_response (GtkWidget *dialog,
- gint response,
+ int response,
gpointer data)
{
GtkPageSetupUnixDialog *psd;
static void preview_iface_init (GtkPrintOperationPreviewIface *iface);
static GtkPageSetup *create_page_setup (GtkPrintOperation *op);
static void common_render_page (GtkPrintOperation *op,
- gint page_nr);
+ int page_nr);
static void increment_page_sequence (PrintPagesData *data);
static void prepare_data (PrintPagesData *data);
static void clamp_page_ranges (PrintPagesData *data);
static void
preview_iface_render_page (GtkPrintOperationPreview *preview,
- gint page_nr)
+ int page_nr)
{
GtkPrintOperation *op;
static gboolean
preview_iface_is_selected (GtkPrintOperationPreview *preview,
- gint page_nr)
+ int page_nr)
{
GtkPrintOperation *op = GTK_PRINT_OPERATION (preview);
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (op);
struct _PrintPagesData
{
GtkPrintOperation *op;
- gint uncollated_copies;
- gint collated_copies;
- gint uncollated, collated, total;
+ int uncollated_copies;
+ int collated_copies;
+ int uncollated, collated, total;
- gint range, num_ranges;
+ int range, num_ranges;
GtkPageRange *ranges;
GtkPageRange one_range;
- gint page;
- gint sheet;
- gint first_position, last_position;
- gint first_sheet;
- gint num_of_sheets;
- gint *pages;
+ int page;
+ int sheet;
+ int first_position, last_position;
+ int first_sheet;
+ int num_of_sheets;
+ int *pages;
GtkWidget *progress;
* static void
* draw_page (GtkPrintOperation *operation,
* GtkPrintContext *context,
- * gint page_nr,
+ * int page_nr,
* gpointer user_data)
* {
* cairo_t *cr;
* PangoLayout *layout;
* gdouble width, text_height;
- * gint layout_height;
+ * int layout_height;
* PangoFontDescription *desc;
*
* cr = gtk_print_context_get_cairo_context (context);
**/
void
gtk_print_operation_set_n_pages (GtkPrintOperation *op,
- gint n_pages)
+ int n_pages)
{
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (op);
**/
void
gtk_print_operation_set_current_page (GtkPrintOperation *op,
- gint current_page)
+ int current_page)
{
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (op);
clamp_page_ranges (PrintPagesData *data)
{
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (data->op);
- gint num_of_correct_ranges;
- gint i;
+ int num_of_correct_ranges;
+ int i;
num_of_correct_ranges = 0;
increment_page_sequence (PrintPagesData *data)
{
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (data->op);
- gint inc;
+ int inc;
if (data->total == -1)
{
static void
common_render_page (GtkPrintOperation *op,
- gint page_nr)
+ int page_nr)
{
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (op);
GtkPageSetup *page_setup;
gdouble x_step, y_step;
gdouble x_scale, y_scale, scale;
gdouble horizontal_offset = 0.0, vertical_offset = 0.0;
- gint columns, rows, x, y, tmp_length;
+ int columns, rows, x, y, tmp_length;
page_setup = gtk_print_context_get_page_setup (print_context);
orientation = gtk_page_setup_get_orientation (page_setup);
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (data->op);
GtkPageSetup *page_setup;
gboolean paginated = FALSE;
- gint i, j, counter;
+ int i, j, counter;
if (priv->manual_collation)
{
for (i = 0; i < data->num_ranges; i++)
priv->nr_of_pages_to_print += data->ranges[i].end - data->ranges[i].start + 1;
- data->pages = g_new (gint, priv->nr_of_pages_to_print);
+ data->pages = g_new (int, priv->nr_of_pages_to_print);
counter = 0;
for (i = 0; i < data->num_ranges; i++)
for (j = data->ranges[i].start; j <= data->ranges[i].end; j++)
static void
handle_progress_response (GtkWidget *dialog,
- gint response,
+ int response,
gpointer data)
{
GtkPrintOperation *op = (GtkPrintOperation *)data;
*
* Returns: the number of pages that will be printed
**/
-gint
+int
gtk_print_operation_get_n_pages_to_print (GtkPrintOperation *op)
{
GtkPrintOperationPrivate *priv = gtk_print_operation_get_instance_private (op);
GtkPrintContext *context);
void (*request_page_setup) (GtkPrintOperation *operation,
GtkPrintContext *context,
- gint page_nr,
+ int page_nr,
GtkPageSetup *setup);
void (*draw_page) (GtkPrintOperation *operation,
GtkPrintContext *context,
- gint page_nr);
+ int page_nr);
void (*end_print) (GtkPrintOperation *operation,
GtkPrintContext *context);
void (*status_changed) (GtkPrintOperation *operation);
const gchar *job_name);
GDK_AVAILABLE_IN_ALL
void gtk_print_operation_set_n_pages (GtkPrintOperation *op,
- gint n_pages);
+ int n_pages);
GDK_AVAILABLE_IN_ALL
void gtk_print_operation_set_current_page (GtkPrintOperation *op,
- gint current_page);
+ int current_page);
GDK_AVAILABLE_IN_ALL
void gtk_print_operation_set_use_full_page (GtkPrintOperation *op,
gboolean full_page);
GDK_AVAILABLE_IN_ALL
gboolean gtk_print_operation_get_embed_page_setup (GtkPrintOperation *op);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_operation_get_n_pages_to_print (GtkPrintOperation *op);
+int gtk_print_operation_get_n_pages_to_print (GtkPrintOperation *op);
GDK_AVAILABLE_IN_ALL
GtkPageSetup *gtk_print_run_page_setup_dialog (GtkWindow *parent,
*/
void
gtk_print_operation_preview_render_page (GtkPrintOperationPreview *preview,
- gint page_nr)
+ int page_nr)
{
g_return_if_fail (GTK_IS_PRINT_OPERATION_PREVIEW (preview));
*/
gboolean
gtk_print_operation_preview_is_selected (GtkPrintOperationPreview *preview,
- gint page_nr)
+ int page_nr)
{
g_return_val_if_fail (GTK_IS_PRINT_OPERATION_PREVIEW (preview), FALSE);
/* methods */
void (*render_page) (GtkPrintOperationPreview *preview,
- gint page_nr);
+ int page_nr);
gboolean (*is_selected) (GtkPrintOperationPreview *preview,
- gint page_nr);
+ int page_nr);
void (*end_preview) (GtkPrintOperationPreview *preview);
/* Padding for future expansion */
GDK_AVAILABLE_IN_ALL
void gtk_print_operation_preview_render_page (GtkPrintOperationPreview *preview,
- gint page_nr);
+ int page_nr);
GDK_AVAILABLE_IN_ALL
void gtk_print_operation_preview_end_preview (GtkPrintOperationPreview *preview);
GDK_AVAILABLE_IN_ALL
gboolean gtk_print_operation_preview_is_selected (GtkPrintOperationPreview *preview,
- gint page_nr);
+ int page_nr);
G_END_DECLS
*
* Returns: the integer value of @key
*/
-gint
+int
gtk_print_settings_get_int_with_default (GtkPrintSettings *settings,
const gchar *key,
- gint def)
+ int def)
{
const gchar *val;
*
* Returns: the integer value of @key
*/
-gint
+int
gtk_print_settings_get_int (GtkPrintSettings *settings,
const gchar *key)
{
void
gtk_print_settings_set_int (GtkPrintSettings *settings,
const gchar *key,
- gint value)
+ int value)
{
gchar buf[128];
g_sprintf (buf, "%d", value);
*
* Returns: the number of copies to print
*/
-gint
+int
gtk_print_settings_get_n_copies (GtkPrintSettings *settings)
{
return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_N_COPIES, 1);
*/
void
gtk_print_settings_set_n_copies (GtkPrintSettings *settings,
- gint num_copies)
+ int num_copies)
{
gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_N_COPIES,
num_copies);
*
* Returns: the number of pages per sheet
*/
-gint
+int
gtk_print_settings_get_number_up (GtkPrintSettings *settings)
{
return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_NUMBER_UP, 1);
*/
void
gtk_print_settings_set_number_up (GtkPrintSettings *settings,
- gint number_up)
+ int number_up)
{
gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_NUMBER_UP,
number_up);
*
* Returns: the resolution in dpi
*/
-gint
+int
gtk_print_settings_get_resolution (GtkPrintSettings *settings)
{
return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION, 300);
*/
void
gtk_print_settings_set_resolution (GtkPrintSettings *settings,
- gint resolution)
+ int resolution)
{
gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION,
resolution);
*
* Returns: the horizontal resolution in dpi
*/
-gint
+int
gtk_print_settings_get_resolution_x (GtkPrintSettings *settings)
{
return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION_X, 300);
*
* Returns: the vertical resolution in dpi
*/
-gint
+int
gtk_print_settings_get_resolution_y (GtkPrintSettings *settings)
{
return gtk_print_settings_get_int_with_default (settings, GTK_PRINT_SETTINGS_RESOLUTION_Y, 300);
*/
void
gtk_print_settings_set_resolution_xy (GtkPrintSettings *settings,
- gint resolution_x,
- gint resolution_y)
+ int resolution_x,
+ int resolution_y)
{
gtk_print_settings_set_int (settings, GTK_PRINT_SETTINGS_RESOLUTION_X,
resolution_x);
*/
GtkPageRange *
gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
- gint *num_ranges)
+ int *num_ranges)
{
const gchar *val;
gchar **range_strs;
GtkPageRange *ranges;
- gint i, n;
+ int i, n;
val = gtk_print_settings_get (settings, GTK_PRINT_SETTINGS_PAGE_RANGES);
for (i = 0; i < n; i++)
{
- gint start, end;
+ int start, end;
gchar *str;
- start = (gint)strtol (range_strs[i], &str, 10);
+ start = (int)strtol (range_strs[i], &str, 10);
end = start;
if (*str == '-')
{
str++;
- end = (gint)strtol (str, NULL, 10);
+ end = (int)strtol (str, NULL, 10);
}
ranges[i].start = start;
void
gtk_print_settings_set_page_ranges (GtkPrintSettings *settings,
GtkPageRange *page_ranges,
- gint num_ranges)
+ int num_ranges)
{
GString *s;
- gint i;
+ int i;
s = g_string_new ("");
*/
struct _GtkPageRange
{
- gint start;
- gint end;
+ int start;
+ int end;
};
GDK_AVAILABLE_IN_ALL
gdouble value,
GtkUnit unit);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_int (GtkPrintSettings *settings,
+int gtk_print_settings_get_int (GtkPrintSettings *settings,
const gchar *key);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_int_with_default (GtkPrintSettings *settings,
+int gtk_print_settings_get_int_with_default (GtkPrintSettings *settings,
const gchar *key,
- gint def);
+ int def);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_int (GtkPrintSettings *settings,
const gchar *key,
- gint value);
+ int value);
#define GTK_PRINT_SETTINGS_PRINTER "printer"
#define GTK_PRINT_SETTINGS_ORIENTATION "orientation"
void gtk_print_settings_set_quality (GtkPrintSettings *settings,
GtkPrintQuality quality);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_n_copies (GtkPrintSettings *settings);
+int gtk_print_settings_get_n_copies (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_n_copies (GtkPrintSettings *settings,
- gint num_copies);
+ int num_copies);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_number_up (GtkPrintSettings *settings);
+int gtk_print_settings_get_number_up (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_number_up (GtkPrintSettings *settings,
- gint number_up);
+ int number_up);
GDK_AVAILABLE_IN_ALL
GtkNumberUpLayout gtk_print_settings_get_number_up_layout (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_number_up_layout (GtkPrintSettings *settings,
GtkNumberUpLayout number_up_layout);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_resolution (GtkPrintSettings *settings);
+int gtk_print_settings_get_resolution (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_resolution (GtkPrintSettings *settings,
- gint resolution);
+ int resolution);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_resolution_x (GtkPrintSettings *settings);
+int gtk_print_settings_get_resolution_x (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_settings_get_resolution_y (GtkPrintSettings *settings);
+int gtk_print_settings_get_resolution_y (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_resolution_xy (GtkPrintSettings *settings,
- gint resolution_x,
- gint resolution_y);
+ int resolution_x,
+ int resolution_y);
GDK_AVAILABLE_IN_ALL
gdouble gtk_print_settings_get_printer_lpi (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
GtkPrintPages pages);
GDK_AVAILABLE_IN_ALL
GtkPageRange * gtk_print_settings_get_page_ranges (GtkPrintSettings *settings,
- gint *num_ranges);
+ int *num_ranges);
GDK_AVAILABLE_IN_ALL
void gtk_print_settings_set_page_ranges (GtkPrintSettings *settings,
GtkPageRange *page_ranges,
- gint num_ranges);
+ int num_ranges);
GDK_AVAILABLE_IN_ALL
GtkPageSet gtk_print_settings_get_page_set (GtkPrintSettings *settings);
GDK_AVAILABLE_IN_ALL
static void update_collate_icon (GtkToggleButton *toggle_button,
GtkPrintUnixDialog *dialog);
static void error_dialogs (GtkPrintUnixDialog *print_dialog,
- gint print_dialog_response_id,
+ int print_dialog_response_id,
gpointer data);
static gboolean page_range_entry_focus_changed (GtkWidget *entry,
GParamSpec *pspec,
static gboolean dialog_get_collate (GtkPrintUnixDialog *dialog);
static gboolean dialog_get_reverse (GtkPrintUnixDialog *dialog);
-static gint dialog_get_n_copies (GtkPrintUnixDialog *dialog);
+static int dialog_get_n_copies (GtkPrintUnixDialog *dialog);
static gboolean set_active_printer (GtkPrintUnixDialog *dialog,
const gchar *printer_name);
gchar *format_for_printer;
- gint current_page;
+ int current_page;
GtkCssNode *collate_paper_node;
GtkCssNode *page_layout_paper_node;
};
*/
static void
error_dialogs (GtkPrintUnixDialog *dialog,
- gint dialog_response_id,
+ int dialog_response_id,
gpointer data)
{
if (dialog != NULL && dialog_response_id == GTK_RESPONSE_OK)
gtk_box_append (GTK_BOX (extension_point), widget);
}
-static gint
+static int
grid_rows (GtkGrid *table)
{
- gint t0, t1, l, t, w, h;
+ int t0, t1, l, t, w, h;
GtkWidget *c;
gboolean first;
GtkWidget *table,
GtkWidget *page)
{
- gint nrows;
+ int nrows;
gtk_printer_option_set_foreach_in_group (options, group,
add_option_to_table,
GList *list, *l;
GtkPageSetup *page_setup;
GtkPaperSize *paper_size;
- gint i;
+ int i;
g_list_store_remove_all (dialog->page_setup_list);
paint_page (GtkPrintUnixDialog *dialog,
GtkWidget *widget,
cairo_t *cr,
- gint x,
- gint y,
+ int x,
+ int y,
const char *text,
- gint text_x)
+ int text_x)
{
GtkStyleContext *context;
- gint width, height;
- gint text_y;
+ int width, height;
+ int text_y;
GdkRGBA color;
width = 20;
GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (data);
GtkWidget *widget = GTK_WIDGET (da);
gboolean collate, reverse, rtl;
- gint copies;
- gint text_x;
- gint x, y, x1, x2, p1, p2;
+ int copies;
+ int text_x;
+ int x, y, x1, x2, p1, p2;
collate = dialog_get_collate (dialog);
reverse = dialog_get_reverse (dialog);
static GtkPageRange *
dialog_get_page_ranges (GtkPrintUnixDialog *dialog,
- gint *n_ranges_out)
+ int *n_ranges_out)
{
- gint i, n_ranges;
+ int i, n_ranges;
const gchar *text, *p;
gchar *next;
GtkPageRange *ranges;
- gint start, end;
+ int start, end;
text = gtk_editable_get_text (GTK_EDITABLE (dialog->page_range_entry));
static void
dialog_set_page_ranges (GtkPrintUnixDialog *dialog,
GtkPageRange *ranges,
- gint n_ranges)
+ int n_ranges)
{
- gint i;
+ int i;
GString *s = g_string_new (NULL);
for (i = 0; i < n_ranges; i++)
gtk_drop_down_set_selected (GTK_DROP_DOWN (dialog->page_set_combo), (guint)val);
}
-static gint
+static int
dialog_get_n_copies (GtkPrintUnixDialog *dialog)
{
GtkAdjustment *adjustment;
const gchar *text;
gchar *endptr = NULL;
- gint n_copies;
+ int n_copies;
adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (dialog->copies_spin));
static void
dialog_set_n_copies (GtkPrintUnixDialog *dialog,
- gint n_copies)
+ int n_copies)
{
gtk_spin_button_set_value (GTK_SPIN_BUTTON (dialog->copies_spin), n_copies);
}
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->reverse_check), reverse);
}
-static gint
+static int
dialog_get_pages_per_sheet (GtkPrintUnixDialog *dialog)
{
const gchar *val;
- gint num;
+ int num;
val = gtk_printer_option_widget_get_value (dialog->pages_per_sheet);
GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (data);
GtkStyleContext *context;
gdouble ratio;
- gint w, h, tmp;
- gint pages_x, pages_y, i, x, y, layout_w, layout_h;
+ int w, h, tmp;
+ int pages_x, pages_y, i, x, y, layout_w, layout_h;
gdouble page_width, page_height;
GtkPageOrientation orientation;
gboolean landscape;
gchar *text;
GdkRGBA color;
GtkNumberUpLayout number_up_layout;
- gint start_x, end_x, start_y, end_y;
- gint dx, dy;
+ int start_x, end_x, start_y, end_y;
+ int dx, dy;
gboolean horizontal;
GtkPageSetup *page_setup;
gdouble paper_width, paper_height;
gdouble pos_x, pos_y;
- gint pages_per_sheet;
+ int pages_per_sheet;
gboolean ltr = TRUE;
orientation = gtk_page_setup_get_orientation (dialog->page_setup);
{
PangoContext *pango_c = NULL;
PangoFontDescription *pango_f = NULL;
- gint font_size = 12 * PANGO_SCALE;
+ int font_size = 12 * PANGO_SCALE;
pos_x += 1;
pos_y += 1;
static void
custom_paper_dialog_response_cb (GtkDialog *custom_paper_dialog,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GtkPrintUnixDialog *dialog = GTK_PRINT_UNIX_DIALOG (user_data);
*/
void
gtk_print_unix_dialog_set_current_page (GtkPrintUnixDialog *dialog,
- gint current_page)
+ int current_page)
{
g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
*
* Returns: the current page of @dialog
*/
-gint
+int
gtk_print_unix_dialog_get_current_page (GtkPrintUnixDialog *dialog)
{
g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), -1);
{
const gchar *printer;
GtkPageRange *ranges;
- gint num_ranges;
+ int num_ranges;
g_return_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog));
g_return_if_fail (settings == NULL || GTK_IS_PRINT_SETTINGS (settings));
GtkPrintSettings *settings;
GtkPrintPages print_pages;
GtkPageRange *ranges;
- gint n_ranges;
+ int n_ranges;
g_return_val_if_fail (GTK_IS_PRINT_UNIX_DIALOG (dialog), NULL);
GtkPageSetup * gtk_print_unix_dialog_get_page_setup (GtkPrintUnixDialog *dialog);
GDK_AVAILABLE_IN_ALL
void gtk_print_unix_dialog_set_current_page (GtkPrintUnixDialog *dialog,
- gint current_page);
+ int current_page);
GDK_AVAILABLE_IN_ALL
-gint gtk_print_unix_dialog_get_current_page (GtkPrintUnixDialog *dialog);
+int gtk_print_unix_dialog_get_current_page (GtkPrintUnixDialog *dialog);
GDK_AVAILABLE_IN_ALL
void gtk_print_unix_dialog_set_settings (GtkPrintUnixDialog *dialog,
GtkPrintSettings *settings);
{
NSString *type;
GdkDisplay *display;
- gint format;
+ int format;
const guchar *data;
NSUInteger length;
GtkQueryPrivate *priv = gtk_query_get_instance_private (query);
gchar *prepared;
gboolean found;
- gint i;
+ int i;
if (!priv->text)
return FALSE;
gdouble fill_level;
gdouble *marks;
- gint *mark_pos;
- gint n_marks;
- gint round_digits; /* Round off value to this many digits, -1 for no rounding */
- gint slide_initial_slider_position;
- gint slide_initial_coordinate_delta;
+ int *mark_pos;
+ int n_marks;
+ int round_digits; /* Round off value to this many digits, -1 for no rounding */
+ int slide_initial_slider_position;
+ int slide_initial_coordinate_delta;
guint flippable : 1;
guint inverted : 1;
GtkTextDirection previous_direction);
static void gtk_range_measure_trough (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline);
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline);
static void gtk_range_allocate_trough (GtkGizmo *gizmo,
int width,
int height,
**/
void
gtk_range_get_slider_range (GtkRange *range,
- gint *slider_start,
- gint *slider_end)
+ int *slider_start,
+ int *slider_end)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
graphene_rect_t slider_bounds;
static void
gtk_range_measure_trough (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkWidget *widget = gtk_widget_get_parent (GTK_WIDGET (gizmo));
GtkRange *range = GTK_RANGE (widget);
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
- gint min, nat;
+ int min, nat;
gtk_widget_measure (priv->slider_widget,
orientation, -1,
GtkBorder *border,
gboolean border_expands_horizontally)
{
- gint extra, shortage;
+ int extra, shortage;
/* Width */
extra = range_width - border->left - border->right - *width;
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
gdouble frac;
gdouble value;
- gint trough_length;
- gint slider_length;
+ int trough_length;
+ int slider_length;
graphene_rect_t slider_bounds;
if (!gtk_widget_compute_bounds (priv->slider_widget, priv->slider_widget, &slider_bounds))
/* During a slide, move the slider as required given new mouse position */
static void
update_slider_position (GtkRange *range,
- gint mouse_x,
- gint mouse_y)
+ int mouse_x,
+ int mouse_y)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
graphene_rect_t trough_bounds;
gdouble mark_value;
gdouble mark_delta;
gdouble zoom;
- gint i;
+ int i;
double x, y;
gtk_widget_translate_coordinates (GTK_WIDGET (range), priv->trough_widget,
if (priv->zoom)
{
int width, height;
- gint size, pos;
+ int size, pos;
width = gtk_widget_get_width (GTK_WIDGET (range));
height = gtk_widget_get_height (GTK_WIDGET (range));
gdouble *newval)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
- gint i;
+ int i;
gdouble mark;
for (i = 0; i < priv->n_marks; i++)
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
GdkRectangle slider;
double x, y;
- gint i;
+ int i;
for (i = 0; i < priv->n_marks; i++)
{
if (priv->round_digits >= 0)
{
gdouble power;
- gint i;
+ int i;
i = priv->round_digits;
power = 1;
void
_gtk_range_set_stop_values (GtkRange *range,
gdouble *values,
- gint n_values)
+ int n_values)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
- gint i;
+ int i;
g_free (priv->marks);
priv->marks = g_new (gdouble, n_values);
g_free (priv->mark_pos);
- priv->mark_pos = g_new (gint, n_values);
+ priv->mark_pos = g_new (int, n_values);
priv->n_marks = n_values;
gtk_range_calc_marks (range);
}
-gint
+int
_gtk_range_get_stop_positions (GtkRange *range,
- gint **values)
+ int **values)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
gtk_range_calc_marks (range);
if (values)
- *values = g_memdup (priv->mark_pos, priv->n_marks * sizeof (gint));
+ *values = g_memdup (priv->mark_pos, priv->n_marks * sizeof (int));
return priv->n_marks;
}
*/
void
gtk_range_set_round_digits (GtkRange *range,
- gint round_digits)
+ int round_digits)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
*
* Returns: the number of digits to round to
*/
-gint
+int
gtk_range_get_round_digits (GtkRange *range)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
GdkRectangle *range_rect);
GDK_AVAILABLE_IN_ALL
void gtk_range_get_slider_range (GtkRange *range,
- gint *slider_start,
- gint *slider_end);
+ int *slider_start,
+ int *slider_end);
GDK_AVAILABLE_IN_ALL
void gtk_range_set_increments (GtkRange *range,
gdouble gtk_range_get_fill_level (GtkRange *range);
GDK_AVAILABLE_IN_ALL
void gtk_range_set_round_digits (GtkRange *range,
- gint round_digits);
+ int round_digits);
GDK_AVAILABLE_IN_ALL
-gint gtk_range_get_round_digits (GtkRange *range);
+int gtk_range_get_round_digits (GtkRange *range);
G_END_DECLS
gboolean _gtk_range_get_has_origin (GtkRange *range);
void _gtk_range_set_stop_values (GtkRange *range,
gdouble *values,
- gint n_values);
-gint _gtk_range_get_stop_positions (GtkRange *range,
- gint **values);
+ int n_values);
+int _gtk_range_get_stop_positions (GtkRange *range,
+ int **values);
GtkWidget *gtk_range_get_slider_widget (GtkRange *range);
GtkWidget *gtk_range_get_trough_widget (GtkRange *range);
gboolean is_private;
- gint ref_count;
+ int ref_count;
};
struct _GtkRecentManagerPrivate
guint is_dirty : 1;
- gint size;
+ int size;
GBookmarkFile *recent_items;
static void gtk_recent_manager_set_filename (GtkRecentManager *manager,
const gchar *filename);
static void gtk_recent_manager_clamp_to_age (GtkRecentManager *manager,
- gint age);
+ int age);
static void gtk_recent_manager_clamp_to_size (GtkRecentManager *manager,
- const gint size);
+ const int size);
static void gtk_recent_manager_enabled_changed (GtkRecentManager *manager);
else
{
GtkSettings *settings;
- gint age;
- gint max_size = MAX_LIST_SIZE;
+ int age;
+ int max_size = MAX_LIST_SIZE;
gboolean enabled;
settings = gtk_settings_get_default ();
{
GtkRecentManagerPrivate *priv = manager->priv;
GError *read_error;
- gint size;
+ int size;
if (!priv->recent_items)
{
if (data->groups && ((char*)data->groups)[0] != '\0')
{
- gint j;
+ int j;
for (j = 0; (data->groups)[j] != NULL; j++)
g_bookmark_file_add_group (priv->recent_items, uri, (data->groups)[j]);
* Returns: the number of items that have been removed from the
* recently used resources list
*/
-gint
+int
gtk_recent_manager_purge_items (GtkRecentManager *manager,
GError **error)
{
GtkRecentManagerPrivate *priv;
- gint count, purged;
+ int count, purged;
g_return_val_if_fail (GTK_IS_RECENT_MANAGER (manager), -1);
static void
gtk_recent_manager_clamp_to_age (GtkRecentManager *manager,
- gint age)
+ int age)
{
GtkRecentManagerPrivate *priv = manager->priv;
gchar **uris;
{
const gchar *uri = uris[i];
time_t modified;
- gint item_age;
+ int item_age;
modified = g_bookmark_file_get_modified (priv->recent_items, uri, NULL);
- item_age = (gint) ((now - modified) / (60 * 60 * 24));
+ item_age = (int) ((now - modified) / (60 * 60 * 24));
if (item_age > age)
g_bookmark_file_remove_item (priv->recent_items, uri, NULL);
}
static void
gtk_recent_manager_clamp_to_size (GtkRecentManager *manager,
- const gint size)
+ const int size)
{
GtkRecentManagerPrivate *priv = manager->priv;
gchar **uris;
* Returns: a positive integer containing the number of days
* elapsed since the time this resource was last modified
*/
-gint
+int
gtk_recent_info_get_age (GtkRecentInfo *info)
{
time_t now, delta;
- gint retval;
+ int retval;
g_return_val_if_fail (info != NULL, -1);
delta = now - info->modified;
- retval = (gint) (delta / (60 * 60 * 24));
+ retval = (int) (delta / (60 * 60 * 24));
return retval;
}
GDK_AVAILABLE_IN_ALL
GList * gtk_recent_manager_get_items (GtkRecentManager *manager);
GDK_AVAILABLE_IN_ALL
-gint gtk_recent_manager_purge_items (GtkRecentManager *manager,
+int gtk_recent_manager_purge_items (GtkRecentManager *manager,
GError **error);
GDK_AVAILABLE_IN_ALL
gchar * gtk_recent_info_get_uri_display (GtkRecentInfo *info) G_GNUC_MALLOC;
GDK_AVAILABLE_IN_ALL
-gint gtk_recent_info_get_age (GtkRecentInfo *info);
+int gtk_recent_info_get_age (GtkRecentInfo *info);
GDK_AVAILABLE_IN_ALL
gboolean gtk_recent_info_is_local (GtkRecentInfo *info);
GDK_AVAILABLE_IN_ALL
void gtk_css_style_render_icon_get_extents (GtkCssStyle *style,
GdkRectangle *extents,
- gint x,
- gint y,
- gint width,
- gint height);
+ int x,
+ int y,
+ int width,
+ int height);
G_END_DECLS
} Arc;
static inline guint
-mem_hash (gconstpointer v, gint len)
+mem_hash (gconstpointer v, int len)
{
const signed char *p;
const signed char *end;
GtkWidget *top_marks_widget;
GtkWidget *bottom_marks_widget;
- gint digits;
+ int digits;
GtkScaleFormatValueFunc format_value_func;
gpointer format_value_func_user_data;
GtkBorder *border);
static void gtk_scale_finalize (GObject *object);
static void gtk_scale_real_get_layout_offsets (GtkScale *scale,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
static void gtk_scale_buildable_interface_init (GtkBuildableIface *iface);
static gboolean gtk_scale_buildable_custom_tag_start (GtkBuildable *buildable,
GtkBuilder *builder,
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_scale_buildable_interface_init))
-static gint
+static int
compare_marks (gconstpointer a, gconstpointer b, gpointer data)
{
gboolean inverted = GPOINTER_TO_INT (data);
- gint val;
+ int val;
const GtkScaleMark *ma, *mb;
val = inverted ? -1 : 1;
{
GtkScaleMark *mark;
GSList *m;
- gint i, n;
+ int i, n;
gdouble *values;
priv->marks = g_slist_sort_with_data (priv->marks,
gdouble step)
{
GtkAdjustment *adj;
- gint digits;
+ int digits;
g_return_val_if_fail (min < max, NULL);
g_return_val_if_fail (step != 0.0, NULL);
}
else
{
- digits = abs ((gint) floor (log10 (fabs (step))));
+ digits = abs ((int) floor (log10 (fabs (step))));
if (digits > 5)
digits = 5;
}
*/
void
gtk_scale_set_digits (GtkScale *scale,
- gint digits)
+ int digits)
{
GtkScalePrivate *priv = gtk_scale_get_instance_private (scale);
GtkRange *range;
*
* Returns: the number of decimal places that are displayed
*/
-gint
+int
gtk_scale_get_digits (GtkScale *scale)
{
GtkScalePrivate *priv = gtk_scale_get_instance_private (scale);
static void
gtk_scale_measure_mark (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkScaleMark *mark = g_object_get_data (G_OBJECT (gizmo), "mark");
static void
gtk_scale_measure_marks (GtkGizmo *gizmo,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkWidget *widget = GTK_WIDGET (gizmo);
GtkScale *scale = GTK_SCALE (gtk_widget_get_parent (widget));;
static void
gtk_scale_real_get_layout_offsets (GtkScale *scale,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
GtkScalePrivate *priv = gtk_scale_get_instance_private (scale);
graphene_rect_t value_bounds;
static gchar *
weed_out_neg_zero (gchar *str,
- gint digits)
+ int digits)
{
if (str[0] == '-')
{
*/
void
gtk_scale_get_layout_offsets (GtkScale *scale,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
- gint local_x = 0;
- gint local_y = 0;
+ int local_x = 0;
+ int local_y = 0;
g_return_if_fail (GTK_IS_SCALE (scale));
GtkScaleMark *mark;
GSList *m;
gdouble *values;
- gint n, i;
+ int n, i;
GtkWidget *marks_widget;
g_return_if_fail (GTK_IS_SCALE (scale));
GtkRangeClass parent_class;
void (* get_layout_offsets) (GtkScale *scale,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
/*< private >*/
gdouble step);
GDK_AVAILABLE_IN_ALL
void gtk_scale_set_digits (GtkScale *scale,
- gint digits);
+ int digits);
GDK_AVAILABLE_IN_ALL
-gint gtk_scale_get_digits (GtkScale *scale);
+int gtk_scale_get_digits (GtkScale *scale);
GDK_AVAILABLE_IN_ALL
void gtk_scale_set_draw_value (GtkScale *scale,
gboolean draw_value);
PangoLayout * gtk_scale_get_layout (GtkScale *scale);
GDK_AVAILABLE_IN_ALL
void gtk_scale_get_layout_offsets (GtkScale *scale,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
GDK_AVAILABLE_IN_ALL
void gtk_scale_add_mark (GtkScale *scale,
guint propagate_natural_height : 1;
guint smooth_scroll : 1;
- gint min_content_width;
- gint min_content_height;
- gint max_content_width;
- gint max_content_height;
+ int min_content_width;
+ int min_content_height;
+ int max_content_width;
+ int max_content_height;
guint scroll_events_overshoot_id;
static void gtk_scrolled_window_cancel_deceleration (GtkScrolledWindow *scrolled_window);
static gboolean _gtk_scrolled_window_get_overshoot (GtkScrolledWindow *scrolled_window,
- gint *overshoot_x,
- gint *overshoot_y);
+ int *overshoot_x,
+ int *overshoot_y);
static void gtk_scrolled_window_start_deceleration (GtkScrolledWindow *scrolled_window);
gtk_scrolled_window_invalidate_overshoot (GtkScrolledWindow *scrolled_window)
{
GtkAllocation child_allocation;
- gint overshoot_x, overshoot_y;
+ int overshoot_x, overshoot_y;
if (!_gtk_scrolled_window_get_overshoot (scrolled_window, &overshoot_x, &overshoot_y))
return;
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (sw);
graphene_rect_t indicator_bounds;
- gint distance;
+ int distance;
if (!gtk_widget_compute_bounds (indicator->scrollbar, GTK_WIDGET (sw), &indicator_bounds))
return FALSE;
GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
GtkAllocation child_allocation;
- gint sb_width;
- gint sb_height;
+ int sb_width;
+ int sb_height;
/* Get possible scrollbar dimensions */
gtk_widget_measure (priv->vscrollbar, GTK_ORIENTATION_HORIZONTAL, -1,
if (priv->child && gtk_widget_get_visible (priv->child))
{
- gint child_scroll_width;
- gint child_scroll_height;
+ int child_scroll_width;
+ int child_scroll_height;
gboolean previous_hvis;
gboolean previous_vvis;
guint count = 0;
}
else
{
- gint min = priv->min_content_width >= 0 ? priv->min_content_width : 0;
- gint max = priv->max_content_width >= 0 ? priv->max_content_width : G_MAXINT;
+ int min = priv->min_content_width >= 0 ? priv->min_content_width : 0;
+ int max = priv->max_content_width >= 0 ? priv->max_content_width : G_MAXINT;
minimum_req = CLAMP (minimum_req, min, max);
natural_req = CLAMP (natural_req, min, max);
}
else
{
- gint min = priv->min_content_height >= 0 ? priv->min_content_height : 0;
- gint max = priv->max_content_height >= 0 ? priv->max_content_height : G_MAXINT;
+ int min = priv->min_content_height >= 0 ? priv->min_content_height : 0;
+ int max = priv->max_content_height >= 0 ? priv->max_content_height : G_MAXINT;
minimum_req = CLAMP (minimum_req, min, max);
natural_req = CLAMP (natural_req, min, max);
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
GtkWidget *widget = GTK_WIDGET (scrolled_window);
- gint overshoot_x, overshoot_y;
+ int overshoot_x, overshoot_y;
GtkStyleContext *context;
GdkRectangle rect;
g_quark_from_static_string (GTK_STYLE_CLASS_TOP),
g_quark_from_static_string (GTK_STYLE_CLASS_BOTTOM),
};
- gint i;
+ int i;
gtk_widget_set_focusable (widget, TRUE);
GtkAllocation *allocation)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
- gint sb_width;
- gint sb_height;
+ int sb_width;
+ int sb_height;
int width, height;
g_return_if_fail (scrolled_window != NULL);
static gboolean
_gtk_scrolled_window_get_overshoot (GtkScrolledWindow *scrolled_window,
- gint *overshoot_x,
- gint *overshoot_y)
+ int *overshoot_x,
+ int *overshoot_y)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
GtkAdjustment *vadjustment, *hadjustment;
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
GtkAllocation child_allocation, content_allocation;
GtkWidget *widget = GTK_WIDGET (scrolled_window);
- gint sb_height, sb_width;
+ int sb_height, sb_width;
gtk_scrolled_window_inner_allocation (scrolled_window, &content_allocation);
gtk_widget_measure (priv->vscrollbar, GTK_ORIENTATION_HORIZONTAL, -1,
*
* Returns: the minimum content width
*/
-gint
+int
gtk_scrolled_window_get_min_content_width (GtkScrolledWindow *scrolled_window)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*/
void
gtk_scrolled_window_set_min_content_width (GtkScrolledWindow *scrolled_window,
- gint width)
+ int width)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*
* Returns: the minimal content height
*/
-gint
+int
gtk_scrolled_window_get_min_content_height (GtkScrolledWindow *scrolled_window)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*/
void
gtk_scrolled_window_set_min_content_height (GtkScrolledWindow *scrolled_window,
- gint height)
+ int height)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*/
void
gtk_scrolled_window_set_max_content_width (GtkScrolledWindow *scrolled_window,
- gint width)
+ int width)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*
* Returns: the maximum content width, or -1
*/
-gint
+int
gtk_scrolled_window_get_max_content_width (GtkScrolledWindow *scrolled_window)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*/
void
gtk_scrolled_window_set_max_content_height (GtkScrolledWindow *scrolled_window,
- gint height)
+ int height)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
*
* Returns: the maximum content height, or -1
*/
-gint
+int
gtk_scrolled_window_get_max_content_height (GtkScrolledWindow *scrolled_window)
{
GtkScrolledWindowPrivate *priv = gtk_scrolled_window_get_instance_private (scrolled_window);
gboolean gtk_scrolled_window_get_has_frame (GtkScrolledWindow *scrolled_window);
GDK_AVAILABLE_IN_ALL
-gint gtk_scrolled_window_get_min_content_width (GtkScrolledWindow *scrolled_window);
+int gtk_scrolled_window_get_min_content_width (GtkScrolledWindow *scrolled_window);
GDK_AVAILABLE_IN_ALL
void gtk_scrolled_window_set_min_content_width (GtkScrolledWindow *scrolled_window,
- gint width);
+ int width);
GDK_AVAILABLE_IN_ALL
-gint gtk_scrolled_window_get_min_content_height (GtkScrolledWindow *scrolled_window);
+int gtk_scrolled_window_get_min_content_height (GtkScrolledWindow *scrolled_window);
GDK_AVAILABLE_IN_ALL
void gtk_scrolled_window_set_min_content_height (GtkScrolledWindow *scrolled_window,
- gint height);
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_scrolled_window_set_kinetic_scrolling (GtkScrolledWindow *scrolled_window,
gboolean kinetic_scrolling);
GDK_AVAILABLE_IN_ALL
void gtk_scrolled_window_set_max_content_width (GtkScrolledWindow *scrolled_window,
- gint width);
+ int width);
GDK_AVAILABLE_IN_ALL
-gint gtk_scrolled_window_get_max_content_width (GtkScrolledWindow *scrolled_window);
+int gtk_scrolled_window_get_max_content_width (GtkScrolledWindow *scrolled_window);
GDK_AVAILABLE_IN_ALL
void gtk_scrolled_window_set_max_content_height (GtkScrolledWindow *scrolled_window,
- gint height);
+ int height);
GDK_AVAILABLE_IN_ALL
-gint gtk_scrolled_window_get_max_content_height (GtkScrolledWindow *scrolled_window);
+int gtk_scrolled_window_get_max_content_height (GtkScrolledWindow *scrolled_window);
GDK_AVAILABLE_IN_ALL
void gtk_scrolled_window_set_propagate_natural_width (GtkScrolledWindow *scrolled_window,
GdkDisplay *display;
GSList *style_cascades;
GtkCssProvider *theme_provider;
- gint font_size;
+ int font_size;
gboolean font_size_absolute;
gchar *font_family;
cairo_font_options_t *font_options;
GtkStyleCascade *
_gtk_settings_get_style_cascade (GtkSettings *settings,
- gint scale)
+ int scale)
{
GtkStyleCascade *new_cascade;
GSList *list;
static void
settings_update_double_click (GtkSettings *settings)
{
- gint double_click_time;
- gint double_click_distance;
+ int double_click_time;
+ int double_click_distance;
g_object_get (settings,
"gtk-double-click-time", &double_click_time,
settings_update_cursor_theme (GtkSettings *settings)
{
gchar *theme = NULL;
- gint size = 0;
+ int size = 0;
g_object_get (settings,
"gtk-cursor-theme-name", &theme,
static void
settings_update_font_options (GtkSettings *settings)
{
- gint hinting;
+ int hinting;
gchar *hint_style_str;
cairo_hint_style_t hint_style;
- gint antialias;
+ int antialias;
cairo_antialias_t antialias_mode;
gchar *rgba_str;
cairo_subpixel_order_t subpixel_order;
GKeyFile *keyfile;
gchar **keys;
gsize n_keys;
- gint i;
+ int i;
error = NULL;
keys = NULL;
case G_TYPE_INT:
case G_TYPE_UINT:
{
- gint i_val;
+ int i_val;
g_value_init (&svalue.value, G_TYPE_LONG);
i_val = g_key_file_get_integer (keyfile, "Settings", key, &error);
settings_update_xsettings (GtkSettings *settings)
{
GParamSpec **pspecs;
- gint i;
+ int i;
pspecs = g_object_class_list_properties (G_OBJECT_GET_CLASS (settings), NULL);
for (i = 0; pspecs[i]; i++)
return g_value_get_boolean (&svalue->value);
}
-gint
+int
gtk_settings_get_dnd_drag_threshold (GtkSettings *settings)
{
GtkSettingsPropertyValue *svalue = &settings->property_values[PROP_DND_DRAG_THRESHOLD - 1];
return settings->font_family;
}
-gint
+int
gtk_settings_get_font_size (GtkSettings *settings)
{
settings_update_font_name (settings);
gtk_settings_get_font_options (GtkSettings *settings);
GdkDisplay *_gtk_settings_get_display (GtkSettings *settings);
GtkStyleCascade *_gtk_settings_get_style_cascade (GtkSettings *settings,
- gint scale);
+ int scale);
typedef enum
{
const gchar *name);
gboolean gtk_settings_get_enable_animations (GtkSettings *settings);
-gint gtk_settings_get_dnd_drag_threshold (GtkSettings *settings);
+int gtk_settings_get_dnd_drag_threshold (GtkSettings *settings);
const gchar *gtk_settings_get_font_family (GtkSettings *settings);
-gint gtk_settings_get_font_size (GtkSettings *settings);
+int gtk_settings_get_font_size (GtkSettings *settings);
gboolean gtk_settings_get_font_size_is_absolute (GtkSettings *settings);
G_END_DECLS
gchar key_label[6];
const gchar *tmp;
gunichar ch;
- gint i = 0;
+ int i = 0;
gchar **retval;
if (modifier & GDK_SHIFT_MASK)
GdkModifierType modifier)
{
gchar **keys = NULL;
- gint i;
+ int i;
guint n_mods;
keys = get_labels (key, modifier, &n_mods);
const gchar *str)
{
gchar **accels;
- gint k;
+ int k;
GdkModifierType modifier = 0;
guint key = 0;
gboolean retval = TRUE;
const gchar *str)
{
gchar **accels;
- gint k;
+ int k;
gboolean retval = TRUE;
accels = g_strsplit (str, "+", 0);
gtk_shortcut_label_rebuild (GtkShortcutLabel *self)
{
gchar **accels;
- gint k;
+ int k;
clear_children (self);
GtkBoxClass parent_class;
gboolean (* change_current_page) (GtkShortcutsSection *self,
- gint offset);
+ int offset);
};
static void gtk_shortcuts_section_reflow_groups (GtkShortcutsSection *self);
static gboolean gtk_shortcuts_section_change_current_page (GtkShortcutsSection *self,
- gint offset);
+ int offset);
static void gtk_shortcuts_section_pan_gesture_pan (GtkGesturePan *gesture,
GtkPanDirection direction,
static gboolean
gtk_shortcuts_section_change_current_page (GtkShortcutsSection *self,
- gint offset)
+ int offset)
{
GtkWidget *child;
* @trigger1 is found, respectively, to be less than, to match,
* or be greater than @trigger2.
**/
-gint
+int
gtk_shortcut_trigger_compare (gconstpointer trigger1,
gconstpointer trigger2)
{
gboolean gtk_shortcut_trigger_equal (gconstpointer trigger1,
gconstpointer trigger2);
GDK_AVAILABLE_IN_ALL
-gint gtk_shortcut_trigger_compare (gconstpointer trigger1,
+int gtk_shortcut_trigger_compare (gconstpointer trigger1,
gconstpointer trigger2);
GDK_AVAILABLE_IN_ALL
GtkWidget *label_widget;
gboolean ejectable;
GtkWidget *eject_button;
- gint order_index;
+ int order_index;
GtkPlacesSidebarSectionType section_type;
GtkPlacesSidebarPlaceType place_type;
gchar *uri;
{
CloudProvidersAccount *account;
GIcon *end_icon;
- gint provider_status;
+ int provider_status;
account = CLOUD_PROVIDERS_ACCOUNT (self->cloud_provider_account);
provider_status = cloud_providers_account_get_status (account);
add_widget_to_closure (GHashTable *widgets,
GHashTable *groups,
GtkWidget *widget,
- gint orientation)
+ int orientation)
{
GSList *tmp_groups, *tmp_widgets;
typedef struct {
gchar *name;
- gint line;
- gint col;
+ int line;
+ int col;
} ItemData;
static void
return GTK_WIDGET_GET_CLASS (widget)->get_request_mode (widget);
}
-static gint
+static int
get_number (GtkCssValue *value)
{
double d = _gtk_css_number_value_get (value, 100);
static void
gtk_widget_query_size_for_orientation (GtkWidget *widget,
GtkOrientation orientation,
- gint for_size,
- gint *minimum,
- gint *natural,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int for_size,
+ int *minimum,
+ int *natural,
+ int *minimum_baseline,
+ int *natural_baseline)
{
const gboolean baselines_requested = (minimum_baseline != NULL || natural_baseline != NULL);
SizeRequestCache *cache;
- gint min_size = 0;
- gint nat_size = 0;
- gint min_baseline = -1;
- gint nat_baseline = -1;
+ int min_size = 0;
+ int nat_size = 0;
+ int min_baseline = -1;
+ int nat_baseline = -1;
gboolean found_in_cache;
gtk_widget_ensure_resize (widget);
}
}
-static gint
+static int
compare_gap (gconstpointer p1,
gconstpointer p2,
gpointer data)
const guint *c1 = p1;
const guint *c2 = p2;
- const gint d1 = MAX (sizes[*c1].natural_size -
+ const int d1 = MAX (sizes[*c1].natural_size -
sizes[*c1].minimum_size,
0);
- const gint d2 = MAX (sizes[*c2].natural_size -
+ const int d2 = MAX (sizes[*c2].natural_size -
sizes[*c2].minimum_size,
0);
- gint delta = (d2 - d1);
+ int delta = (d2 - d1);
if (0 == delta)
delta = (*c2 - *c1);
* Returns: The remainder of @extra_space after redistributing space
* to @sizes.
*/
-gint
-gtk_distribute_natural_allocation (gint extra_space,
+int
+gtk_distribute_natural_allocation (int extra_space,
guint n_requested_sizes,
GtkRequestedSize *sizes)
{
guint *spreading;
- gint i;
+ int i;
g_return_val_if_fail (extra_space >= 0, 0);
* Sort order and reducing remaining space by assigned space
* ensures that space is distributed equally.
*/
- gint glue = (extra_space + i) / (i + 1);
- gint gap = sizes[(spreading[i])].natural_size
+ int glue = (extra_space + i) / (i + 1);
+ int gap = sizes[(spreading[i])].natural_size
- sizes[(spreading[i])].minimum_size;
- gint extra = MIN (glue, gap);
+ int extra = MIN (glue, gap);
sizes[spreading[i]].minimum_size += extra;
struct _GtkRequestedSize
{
gpointer data;
- gint minimum_size;
- gint natural_size;
+ int minimum_size;
+ int natural_size;
};
/* General convenience function to aid in allocating natural sizes */
GDK_AVAILABLE_IN_ALL
-gint gtk_distribute_natural_allocation (gint extra_space,
+int gtk_distribute_natural_allocation (int extra_space,
guint n_requested_sizes,
GtkRequestedSize *sizes);
static void
free_sizes_x (SizeRequestX **sizes)
{
- gint i;
+ int i;
for (i = 0; i < GTK_SIZE_REQUEST_CACHED_SIZES && sizes[i] != NULL; i++)
g_slice_free (SizeRequestX, sizes[i]);
static void
free_sizes_y (SizeRequestY **sizes)
{
- gint i;
+ int i;
for (i = 0; i < GTK_SIZE_REQUEST_CACHED_SIZES && sizes[i] != NULL; i++)
g_slice_free (SizeRequestY, sizes[i]);
#define GTK_SIZE_REQUEST_CACHED_SIZES (5)
typedef struct {
- gint minimum_size;
- gint natural_size;
+ int minimum_size;
+ int natural_size;
} CachedSizeX;
typedef struct {
- gint minimum_size;
- gint natural_size;
- gint minimum_baseline;
- gint natural_baseline;
+ int minimum_size;
+ int natural_size;
+ int minimum_baseline;
+ int natural_baseline;
} CachedSizeY;
typedef struct
{
- gint lower_for_size; /* The minimum for_size with the same result */
- gint upper_for_size; /* The maximum for_size with the same result */
+ int lower_for_size; /* The minimum for_size with the same result */
+ int upper_for_size; /* The maximum for_size with the same result */
CachedSizeX cached_size;
} SizeRequestX;
typedef struct
{
- gint lower_for_size; /* The minimum for_size with the same result */
- gint upper_for_size; /* The maximum for_size with the same result */
+ int lower_for_size; /* The minimum for_size with the same result */
+ int upper_for_size; /* The maximum for_size with the same result */
CachedSizeY cached_size;
} SizeRequestY;
struct _GtkSortKeys
{
const GtkSortKeysClass *klass;
- gint ref_count;
+ int ref_count;
gsize key_size;
gsize key_align; /* must be power of 2 */
* // Provides a function to retrieve an integer value from a GtkSpinButton
* // and creates a spin button to model percentage values.
*
- * gint
+ * int
* grab_int_value (GtkSpinButton *button,
* gpointer user_data)
* {
{
GtkWidgetClass parent_class;
- gint (*input) (GtkSpinButton *spin_button,
- gdouble *new_value);
- gint (*output) (GtkSpinButton *spin_button);
+ int (*input) (GtkSpinButton *spin_button,
+ gdouble *new_value);
+ int (*output) (GtkSpinButton *spin_button);
void (*value_changed) (GtkSpinButton *spin_button);
/* Action signals for keybindings, do not connect to these */
gdouble val);
static void gtk_spin_button_insert_text (GtkEditable *editable,
const gchar *new_text,
- gint new_text_length,
- gint *position);
+ int new_text_length,
+ int *position);
static void gtk_spin_button_real_spin (GtkSpinButton *spin_button,
gdouble step);
static void gtk_spin_button_real_change_value (GtkSpinButton *spin,
GtkScrollType scroll);
-static gint gtk_spin_button_default_input (GtkSpinButton *spin_button,
+static int gtk_spin_button_default_input (GtkSpinButton *spin_button,
gdouble *new_val);
static void gtk_spin_button_default_output (GtkSpinButton *spin_button);
static gchar *
weed_out_neg_zero (gchar *str,
- gint digits)
+ int digits)
{
if (str[0] == '-')
{
GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->state_flags_changed (widget, previous_state);
}
-static gint
+static int
gtk_spin_button_timer (GtkSpinButton *spin_button)
{
gboolean retval = FALSE;
static void
gtk_spin_button_insert_text (GtkEditable *editable,
const gchar *new_text,
- gint new_text_length,
- gint *position)
+ int new_text_length,
+ int *position)
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (editable);
{
struct lconv *lc;
gboolean sign;
- gint dotpos = -1;
- gint i;
+ int dotpos = -1;
+ int i;
guint32 pos_sign;
guint32 neg_sign;
- gint entry_length;
+ int entry_length;
const gchar *entry_text;
entry_text = gtk_editable_get_text (GTK_EDITABLE (spin->entry));
}
if (dotpos > -1 && *position > dotpos &&
- (gint)spin->digits - entry_length
+ (int)spin->digits - entry_length
+ dotpos - new_text_length + 1 < 0)
return;
else if (new_text[i] == *(lc->decimal_point))
{
if (!spin->digits || dotpos > -1 ||
- (new_text_length - 1 - i + entry_length - *position > (gint)spin->digits))
+ (new_text_length - 1 - i + entry_length - *position > (int)spin->digits))
return;
dotpos = *position + i;
}
g_signal_emit (spin_button, spinbutton_signals[WRAPPED], 0);
}
-static gint
+static int
gtk_spin_button_default_input (GtkSpinButton *spin_button,
gdouble *new_val)
{
{
GtkAdjustment *adjustment;
GtkSpinButton *spin;
- gint digits;
+ int digits;
g_return_val_if_fail (min <= max, NULL);
g_return_val_if_fail (step != 0.0, NULL);
if (fabs (step) >= 1.0 || step == 0.0)
digits = 0;
else {
- digits = abs ((gint) floor (log10 (fabs (step))));
+ digits = abs ((int) floor (log10 (fabs (step))));
if (digits > MAX_DIGITS)
digits = MAX_DIGITS;
}
*
* Returns: the value of @spin_button
*/
-gint
+int
gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button)
{
gdouble val;
gtk_adjustment_set_value (spin_button->adjustment, value);
else
{
- gint return_val = FALSE;
+ int return_val = FALSE;
g_signal_emit (spin_button, spinbutton_signals[OUTPUT], 0, &return_val);
if (!return_val)
gtk_spin_button_default_output (spin_button);
gtk_spin_button_update (GtkSpinButton *spin_button)
{
gdouble val;
- gint error = 0;
- gint return_val;
+ int error = 0;
+ int return_val;
g_return_if_fail (GTK_IS_SPIN_BUTTON (spin_button));
gdouble gtk_spin_button_get_value (GtkSpinButton *spin_button);
GDK_AVAILABLE_IN_ALL
-gint gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button);
+int gtk_spin_button_get_value_as_int (GtkSpinButton *spin_button);
GDK_AVAILABLE_IN_ALL
void gtk_spin_button_set_value (GtkSpinButton *spin_button,
GtkProgressTracker tracker;
gboolean first_frame_skipped;
- gint last_visible_widget_width;
- gint last_visible_widget_height;
+ int last_visible_widget_width;
+ int last_visible_widget_height;
gboolean interpolate_size;
}
}
-static gint
+static int
get_bin_window_x (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
return x;
}
-static gint
+static int
get_bin_window_y (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
GtkStack *stack = GTK_STACK (widget);
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
int widget_width, widget_height;
- gint x, y, width, height, pos_x, pos_y;
+ int x, y, width, height, pos_x, pos_y;
x = y = 0;
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
GtkStackPage *child_info;
GtkWidget *child;
- gint child_min, child_nat;
+ int child_min, child_nat;
GList *l;
*minimum = 0;
**/
void
gtk_style_context_set_scale (GtkStyleContext *context,
- gint scale)
+ int scale)
{
GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context);
*
* Returns: the scale
**/
-gint
+int
gtk_style_context_get_scale (GtkStyleContext *context)
{
GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context);
{
GdkRGBA primary_color;
GdkRGBA secondary_color;
- gint stem_width;
- gint offset;
+ int stem_width;
+ int offset;
cairo_save (cr);
cairo_new_path (cr);
if (draw_arrow)
{
- gint arrow_width;
- gint ax, ay;
+ int arrow_width;
+ int ax, ay;
arrow_width = stem_width + 1;
gboolean draw_arrow,
graphene_rect_t *bounds)
{
- gint stem_width;
- gint offset;
+ int stem_width;
+ int offset;
stem_width = height * aspect_ratio + 1;
if (direction == PANGO_DIRECTION_LTR)
GDK_AVAILABLE_IN_ALL
void gtk_style_context_set_scale (GtkStyleContext *context,
- gint scale);
+ int scale);
GDK_AVAILABLE_IN_ALL
-gint gtk_style_context_get_scale (GtkStyleContext *context);
+int gtk_style_context_get_scale (GtkStyleContext *context);
GDK_AVAILABLE_IN_ALL
void gtk_style_context_add_class (GtkStyleContext *context,
static void
gtk_switch_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkSwitch *self)
static void
gtk_switch_click_gesture_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkSwitch *self)
int *natural_baseline)
{
GtkSwitch *self = GTK_SWITCH (widget);
- gint slider_minimum, slider_natural;
+ int slider_minimum, slider_natural;
int on_nat, off_nat;
gtk_widget_measure (self->slider, orientation, -1,
void gtk_text_set_max_length (GtkText *self,
int length);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_get_max_length (GtkText *self);
+int gtk_text_get_max_length (GtkText *self);
GDK_AVAILABLE_IN_ALL
guint16 gtk_text_get_text_length (GtkText *self);
GdkRGBA *strikethrough_rgba;
/* super/subscript rise, can be negative */
- gint rise;
+ int rise;
guint underline : 4; /* PangoUnderline */
guint overline : 2; /* PangoOverline */
gdouble font_scale;
- gint left_margin;
- gint right_margin;
- gint indent;
+ int left_margin;
+ int right_margin;
+ int indent;
- gint pixels_above_lines;
- gint pixels_below_lines;
- gint pixels_inside_wrap;
+ int pixels_above_lines;
+ int pixels_below_lines;
+ int pixels_inside_wrap;
PangoTabArray *tabs;
guint no_fallback: 1;
guint no_breaks : 1;
guint show_spaces : 3; /* PangoShowFlags */
- gint no_hyphens : 1;
+ int no_hyphens : 1;
GdkRGBA *pg_bg_rgba;
- gint letter_spacing;
+ int letter_spacing;
gchar *font_features;
};
NodeData *next;
/* Height and width of this node */
- gint height;
+ int height;
signed int width : 24;
/* boolean indicating whether the lines below this node are in need of validation.
static GtkTextLine * get_last_line (GtkTextBTree *tree);
static void post_insert_fixup (GtkTextBTree *tree,
GtkTextLine *insert_line,
- gint char_count_delta,
- gint line_count_delta);
+ int char_count_delta,
+ int line_count_delta);
static void gtk_text_btree_node_adjust_toggle_count (GtkTextBTreeNode *node,
GtkTextTagInfo *info,
- gint adjust);
+ int adjust);
static gboolean gtk_text_btree_node_has_tag (GtkTextBTreeNode *node,
GtkTextTag *tag);
gpointer view_id);
static void gtk_text_btree_node_get_size (GtkTextBTreeNode *node,
gpointer view_id,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
static GtkTextBTreeNode * gtk_text_btree_node_common_parent (GtkTextBTreeNode *node1,
GtkTextBTreeNode *node2);
static void get_tree_bounds (GtkTextBTree *tree,
GtkTextLine *end_line;
GtkTextLine *line;
GtkTextLine *deleted_lines = NULL; /* List of lines we've deleted */
- gint start_byte_offset;
+ int start_byte_offset;
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
curnode = curline->parent;
while (seg != last_seg)
{
- gint char_count = 0;
+ int char_count = 0;
if (seg == NULL)
{
{
GtkTextLineData *ld;
- gint deleted_width = 0;
- gint deleted_height = 0;
+ int deleted_width = 0;
+ int deleted_height = 0;
line = deleted_lines;
while (line)
void
_gtk_text_btree_insert (GtkTextIter *iter,
const gchar *text,
- gint len)
+ int len)
{
GtkTextLineSegment *prev_seg; /* The segment just before the first
* new segment (NULL means new segment
GtkTextLineSegment *seg;
GtkTextLine *newline;
int chunk_len; /* # characters in current chunk. */
- gint sol; /* start of line */
- gint eol; /* Pointer to character just after last
+ int sol; /* start of line */
+ int eol; /* Pointer to character just after last
* one in current chunk.
*/
- gint delim; /* index of paragraph delimiter */
+ int delim; /* index of paragraph delimiter */
int line_count_delta; /* Counts change to total number of
* lines in file.
*/
int char_count_delta; /* change to number of chars */
GtkTextBTree *tree;
- gint start_byte_index;
+ int start_byte_index;
GtkTextLine *start_line;
g_return_if_fail (text != NULL);
GtkTextLineSegment *prevPtr;
GtkTextLine *line;
GtkTextBTree *tree;
- gint start_byte_offset;
+ int start_byte_offset;
line = _gtk_text_iter_get_text_line (iter);
tree = _gtk_text_iter_get_btree (iter);
static GtkTextLine*
find_line_by_y (GtkTextBTree *tree, BTreeView *view,
- GtkTextBTreeNode *node, gint y, gint *line_top,
+ GtkTextBTreeNode *node, int y, int *line_top,
GtkTextLine *last_line)
{
- gint current_y = 0;
+ int current_y = 0;
#ifdef G_ENABLE_DEBUG
if (GTK_DEBUG_CHECK (TEXT))
while (child != NULL)
{
- gint width;
- gint height;
+ int width;
+ int height;
gtk_text_btree_node_get_size (child, view->view_id,
&width, &height);
GtkTextLine *
_gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
gpointer view_id,
- gint ypixel,
- gint *line_top_out)
+ int ypixel,
+ int *line_top_out)
{
GtkTextLine *line;
BTreeView *view;
GtkTextLine *last_line;
- gint line_top = 0;
+ int line_top = 0;
view = gtk_text_btree_get_view (tree, view_id);
g_return_val_if_fail (view != NULL, NULL);
return line;
}
-static gint
+static int
find_line_top_in_line_list (GtkTextBTree *tree,
BTreeView *view,
GtkTextLine *line,
GtkTextLine *target_line,
- gint y)
+ int y)
{
while (line != NULL)
{
return 0;
}
-gint
+int
_gtk_text_btree_find_line_top (GtkTextBTree *tree,
GtkTextLine *target_line,
gpointer view_id)
{
- gint y = 0;
+ int y = 0;
BTreeView *view;
GSList *nodes;
GSList *iter;
while (child != NULL)
{
- gint width;
- gint height;
+ int width;
+ int height;
if (child == target_node)
break;
void
_gtk_text_btree_get_view_size (GtkTextBTree *tree,
gpointer view_id,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
g_return_if_fail (tree != NULL);
g_return_if_fail (view_id != NULL);
static GtkTextLine*
get_line_internal (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number,
+ int line_number,
+ int *real_line_number,
gboolean include_last)
{
GtkTextBTreeNode *node;
GtkTextLine*
_gtk_text_btree_get_line (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number)
+ int line_number,
+ int *real_line_number)
{
return get_line_internal (tree, line_number, real_line_number, TRUE);
}
GtkTextLine*
_gtk_text_btree_get_line_no_last (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number)
+ int line_number,
+ int *real_line_number)
{
return get_line_internal (tree, line_number, real_line_number, FALSE);
}
GtkTextLine*
_gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
- gint char_index,
- gint *line_start_index,
- gint *real_char_index)
+ int char_index,
+ int *line_start_index,
+ int *real_char_index)
{
GtkTextBTreeNode *node;
GtkTextLine *line;
* _gtk_text_attributes_fill_from_tags() */
GtkTextTag**
_gtk_text_btree_get_tags (const GtkTextIter *iter,
- gint *num_tags)
+ int *num_tags)
{
GtkTextBTreeNode *node;
GtkTextLine *siblingline;
int src, dst, index;
TagInfo tagInfo;
GtkTextLine *line;
- gint byte_index;
+ int byte_index;
#define NUM_TAG_INFOS 10
if (seg->type == >k_text_char_type)
{
gboolean copy = TRUE;
- gint copy_bytes = 0;
- gint copy_start = 0;
+ int copy_bytes = 0;
+ int copy_start = 0;
/* Don't copy if we're invisible; segments are invisible/not
as a whole, no need to check each char */
if (seg == end_seg)
{
/* End is in the same segment; need to copy fewer bytes. */
- gint end_byte = _gtk_text_iter_get_segment_byte (end);
+ int end_byte = _gtk_text_iter_get_segment_byte (end);
copy_bytes = end_byte - copy_start;
}
return str;
}
-gint
+int
_gtk_text_btree_line_count (GtkTextBTree *tree)
{
/* Subtract bogus line at the end; we return a count
return tree->root_node->num_lines - 1;
}
-gint
+int
_gtk_text_btree_char_count (GtkTextBTree *tree)
{
/* Exclude newline in bogus last line and the
int i, index;
GtkTextLine *line;
GtkTextBTree *tree;
- gint byte_index;
+ int byte_index;
line = _gtk_text_iter_get_text_line (iter);
tree = _gtk_text_iter_get_btree (iter);
view = tree->views;
while (view != NULL)
{
- gint start_y, end_y;
+ int start_y, end_y;
GtkTextLineData *ld;
start_y = _gtk_text_btree_find_line_top (tree, start_line, view->view_id);
* Lines
*/
-gint
+int
_gtk_text_line_get_number (GtkTextLine *line)
{
GtkTextLine *line2;
static GtkTextLineSegment*
find_toggle_segment_before_char (GtkTextLine *line,
- gint char_in_line,
+ int char_in_line,
GtkTextTag *tag)
{
GtkTextLineSegment *seg;
static GtkTextLineSegment*
find_toggle_segment_before_byte (GtkTextLine *line,
- gint byte_in_line,
+ int byte_in_line,
GtkTextTag *tag)
{
GtkTextLineSegment *seg;
gboolean
_gtk_text_line_char_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
- gint char_in_line,
+ int char_in_line,
GtkTextTag *tag)
{
GtkTextLineSegment *toggle_seg;
gboolean
_gtk_text_line_byte_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
- gint byte_in_line,
+ int byte_in_line,
GtkTextTag *tag)
{
GtkTextLineSegment *toggle_seg;
{
if (tree->end_iter_line_stamp != tree->chars_changed_stamp)
{
- gint real_line;
+ int real_line;
/* n_lines is without the magic line at the end */
g_assert (_gtk_text_btree_line_count (tree) >= 1);
gtk_text_btree_node_invalidate_upward (line->parent, ld->view_id);
}
-gint
+int
_gtk_text_line_char_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
- gint size;
+ int size;
size = 0;
seg = line->segments;
return size;
}
-gint
+int
_gtk_text_line_byte_count (GtkTextLine *line)
{
GtkTextLineSegment *seg;
- gint size;
+ int size;
size = 0;
seg = line->segments;
return size;
}
-gint
+int
_gtk_text_line_char_index (GtkTextLine *target_line)
{
GSList *node_stack = NULL;
GtkTextBTreeNode *iter;
GtkTextLine *line;
- gint num_chars;
+ int num_chars;
/* Push all our parent nodes onto a stack */
iter = target_line->parent;
GtkTextLineSegment*
_gtk_text_line_byte_to_segment (GtkTextLine *line,
- gint byte_offset,
- gint *seg_offset)
+ int byte_offset,
+ int *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
GtkTextLineSegment*
_gtk_text_line_char_to_segment (GtkTextLine *line,
- gint char_offset,
- gint *seg_offset)
+ int char_offset,
+ int *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
GtkTextLineSegment*
_gtk_text_line_byte_to_any_segment (GtkTextLine *line,
- gint byte_offset,
- gint *seg_offset)
+ int byte_offset,
+ int *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
GtkTextLineSegment*
_gtk_text_line_char_to_any_segment (GtkTextLine *line,
- gint char_offset,
- gint *seg_offset)
+ int char_offset,
+ int *seg_offset)
{
GtkTextLineSegment *seg;
int offset;
return seg;
}
-gint
+int
_gtk_text_line_byte_to_char (GtkTextLine *line,
- gint byte_offset)
+ int byte_offset)
{
- gint char_offset;
+ int char_offset;
GtkTextLineSegment *seg;
g_return_val_if_fail (line != NULL, 0);
}
}
-gint
+int
_gtk_text_line_char_to_byte (GtkTextLine *line,
- gint char_offset)
+ int char_offset)
{
g_warning ("FIXME not implemented");
way to merge the two functions) */
gboolean
_gtk_text_line_byte_locate (GtkTextLine *line,
- gint byte_offset,
+ int byte_offset,
GtkTextLineSegment **segment,
GtkTextLineSegment **any_segment,
- gint *seg_byte_offset,
- gint *line_byte_offset)
+ int *seg_byte_offset,
+ int *line_byte_offset)
{
GtkTextLineSegment *seg;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
- gint offset;
- gint bytes_in_line;
+ int offset;
+ int bytes_in_line;
g_return_val_if_fail (line != NULL, FALSE);
g_return_val_if_fail (byte_offset >= 0, FALSE);
way to merge the two functions) */
gboolean
_gtk_text_line_char_locate (GtkTextLine *line,
- gint char_offset,
+ int char_offset,
GtkTextLineSegment **segment,
GtkTextLineSegment **any_segment,
- gint *seg_char_offset,
- gint *line_char_offset)
+ int *seg_char_offset,
+ int *line_char_offset)
{
GtkTextLineSegment *seg;
GtkTextLineSegment *after_last_indexable;
GtkTextLineSegment *last_indexable;
- gint offset;
- gint chars_in_line;
+ int offset;
+ int chars_in_line;
g_return_val_if_fail (line != NULL, FALSE);
g_return_val_if_fail (char_offset >= 0, FALSE);
void
_gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
- gint byte_offset,
- gint *line_char_offset,
- gint *seg_char_offset)
+ int byte_offset,
+ int *line_char_offset,
+ int *seg_char_offset)
{
GtkTextLineSegment *seg;
int offset;
void
_gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
- gint char_offset,
- gint *line_byte_offset,
- gint *seg_byte_offset)
+ int char_offset,
+ int *line_byte_offset,
+ int *seg_byte_offset)
{
GtkTextLineSegment *seg;
int offset;
}
}
-static gint
+static int
node_compare (GtkTextBTreeNode *lhs,
GtkTextBTreeNode *rhs)
{
}
else
{
- gint ordering;
+ int ordering;
ordering = node_compare (line->parent, info->tag_root);
}
else
{
- gint ordering;
+ int ordering;
ordering = node_compare (line->parent, info->tag_root);
{
if (tree->last_line_stamp != tree->chars_changed_stamp)
{
- gint n_lines;
+ int n_lines;
GtkTextLine *line;
- gint real_line;
+ int real_line;
n_lines = _gtk_text_btree_line_count (tree);
static void
gtk_text_btree_node_adjust_toggle_count (GtkTextBTreeNode *node,
GtkTextTagInfo *info,
- gint adjust)
+ int adjust)
{
Summary *summary;
struct _ValidateState
{
- gint remaining_pixels;
+ int remaining_pixels;
gboolean in_validation;
- gint y;
- gint old_height;
- gint new_height;
+ int y;
+ int old_height;
+ int new_height;
};
static void
gpointer view_id,
ValidateState *state)
{
- gint node_valid = TRUE;
- gint node_width = 0;
- gint node_height = 0;
+ int node_valid = TRUE;
+ int node_width = 0;
+ int node_height = 0;
NodeData *nd = gtk_text_btree_node_ensure_data (node, view_id);
g_return_if_fail (!nd->valid);
gboolean
_gtk_text_btree_validate (GtkTextBTree *tree,
gpointer view_id,
- gint max_pixels,
- gint *y,
- gint *old_height,
- gint *new_height)
+ int max_pixels,
+ int *y,
+ int *old_height,
+ int *new_height)
{
BTreeView *view;
static void
gtk_text_btree_node_compute_view_aggregates (GtkTextBTreeNode *node,
gpointer view_id,
- gint *width_out,
- gint *height_out,
+ int *width_out,
+ int *height_out,
gboolean *valid_out)
{
- gint width = 0;
- gint height = 0;
+ int width = 0;
+ int height = 0;
gboolean valid = TRUE;
if (node->level == 0)
{
NodeData *nd = gtk_text_btree_node_ensure_data (node, view_id);
gboolean valid;
- gint width;
- gint height;
+ int width;
+ int height;
gtk_text_btree_node_compute_view_aggregates (node, view_id,
&width, &height, &valid);
static void
gtk_text_btree_node_get_size (GtkTextBTreeNode *node, gpointer view_id,
- gint *width, gint *height)
+ int *width, int *height)
{
NodeData *nd;
static void
post_insert_fixup (GtkTextBTree *tree,
GtkTextLine *line,
- gint line_count_delta,
- gint char_count_delta)
+ int line_count_delta,
+ int char_count_delta)
{
GtkTextBTreeNode *node;
void
_gtk_change_node_toggle_count (GtkTextBTreeNode *node,
GtkTextTagInfo *info,
- gint delta) /* may be negative */
+ int delta) /* may be negative */
{
Summary *summary, *prevPtr;
GtkTextBTreeNode *node2Ptr;
GtkTextBTreeNode *node,
NodeData *nd)
{
- gint width;
- gint height;
+ int width;
+ int height;
gboolean valid;
BTreeView *view;
GtkTextIter *end);
void _gtk_text_btree_insert (GtkTextIter *iter,
const gchar *text,
- gint len);
+ int len);
void _gtk_text_btree_insert_paintable (GtkTextIter *iter,
GdkPaintable *texture);
/* View stuff */
GtkTextLine *_gtk_text_btree_find_line_by_y (GtkTextBTree *tree,
gpointer view_id,
- gint ypixel,
- gint *line_top_y);
-gint _gtk_text_btree_find_line_top (GtkTextBTree *tree,
+ int ypixel,
+ int *line_top_y);
+int _gtk_text_btree_find_line_top (GtkTextBTree *tree,
GtkTextLine *line,
gpointer view_id);
void _gtk_text_btree_add_view (GtkTextBTree *tree,
gboolean cursors_only);
void _gtk_text_btree_get_view_size (GtkTextBTree *tree,
gpointer view_id,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
gboolean _gtk_text_btree_is_valid (GtkTextBTree *tree,
gpointer view_id);
gboolean _gtk_text_btree_validate (GtkTextBTree *tree,
gpointer view_id,
- gint max_pixels,
- gint *y,
- gint *old_height,
- gint *new_height);
+ int max_pixels,
+ int *y,
+ int *old_height,
+ int *new_height);
void _gtk_text_btree_validate_line (GtkTextBTree *tree,
GtkTextLine *line,
gpointer view_id);
/* "Getters" */
GtkTextLine * _gtk_text_btree_get_line (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number);
+ int line_number,
+ int *real_line_number);
GtkTextLine * _gtk_text_btree_get_line_no_last (GtkTextBTree *tree,
- gint line_number,
- gint *real_line_number);
+ int line_number,
+ int *real_line_number);
GtkTextLine * _gtk_text_btree_get_end_iter_line (GtkTextBTree *tree);
GtkTextLine * _gtk_text_btree_get_line_at_char (GtkTextBTree *tree,
- gint char_index,
- gint *line_start_index,
- gint *real_char_index);
+ int char_index,
+ int *line_start_index,
+ int *real_char_index);
GtkTextTag** _gtk_text_btree_get_tags (const GtkTextIter *iter,
- gint *num_tags);
+ int *num_tags);
gchar *_gtk_text_btree_get_text (const GtkTextIter *start,
const GtkTextIter *end,
gboolean include_hidden,
gboolean include_nonchars);
-gint _gtk_text_btree_line_count (GtkTextBTree *tree);
-gint _gtk_text_btree_char_count (GtkTextBTree *tree);
+int _gtk_text_btree_line_count (GtkTextBTree *tree);
+int _gtk_text_btree_char_count (GtkTextBTree *tree);
gboolean _gtk_text_btree_char_is_invisible (const GtkTextIter *iter);
/* Get iterators (these are implemented in gtktextiter.c) */
void _gtk_text_btree_get_iter_at_char (GtkTextBTree *tree,
GtkTextIter *iter,
- gint char_index);
+ int char_index);
void _gtk_text_btree_get_iter_at_line_char (GtkTextBTree *tree,
GtkTextIter *iter,
- gint line_number,
- gint char_index);
+ int line_number,
+ int char_index);
void _gtk_text_btree_get_iter_at_line_byte (GtkTextBTree *tree,
GtkTextIter *iter,
- gint line_number,
- gint byte_index);
+ int line_number,
+ int byte_index);
gboolean _gtk_text_btree_get_iter_from_string (GtkTextBTree *tree,
GtkTextIter *iter,
const gchar *string);
void _gtk_text_btree_get_iter_at_line (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextLine *line,
- gint byte_offset);
+ int byte_offset);
gboolean _gtk_text_btree_get_iter_at_first_toggle (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextTag *tag);
struct _GtkTextLineData {
gpointer view_id;
GtkTextLineData *next;
- gint height;
- gint top_ink : 16;
- gint bottom_ink : 16;
+ int height;
+ int top_ink : 16;
+ int bottom_ink : 16;
signed int width : 24;
guint valid : 8; /* Actually a boolean */
};
};
-gint _gtk_text_line_get_number (GtkTextLine *line);
+int _gtk_text_line_get_number (GtkTextLine *line);
gboolean _gtk_text_line_char_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
- gint char_in_line,
+ int char_in_line,
GtkTextTag *tag);
gboolean _gtk_text_line_byte_has_tag (GtkTextLine *line,
GtkTextBTree *tree,
- gint byte_in_line,
+ int byte_in_line,
GtkTextTag *tag);
gboolean _gtk_text_line_is_last (GtkTextLine *line,
GtkTextBTree *tree);
gpointer view_id);
void _gtk_text_line_invalidate_wrap (GtkTextLine *line,
GtkTextLineData *ld);
-gint _gtk_text_line_char_count (GtkTextLine *line);
-gint _gtk_text_line_byte_count (GtkTextLine *line);
-gint _gtk_text_line_char_index (GtkTextLine *line);
+int _gtk_text_line_char_count (GtkTextLine *line);
+int _gtk_text_line_byte_count (GtkTextLine *line);
+int _gtk_text_line_char_index (GtkTextLine *line);
GtkTextLineSegment *_gtk_text_line_byte_to_segment (GtkTextLine *line,
- gint byte_offset,
- gint *seg_offset);
+ int byte_offset,
+ int *seg_offset);
GtkTextLineSegment *_gtk_text_line_char_to_segment (GtkTextLine *line,
- gint char_offset,
- gint *seg_offset);
+ int char_offset,
+ int *seg_offset);
gboolean _gtk_text_line_byte_locate (GtkTextLine *line,
- gint byte_offset,
+ int byte_offset,
GtkTextLineSegment **segment,
GtkTextLineSegment **any_segment,
- gint *seg_byte_offset,
- gint *line_byte_offset);
+ int *seg_byte_offset,
+ int *line_byte_offset);
gboolean _gtk_text_line_char_locate (GtkTextLine *line,
- gint char_offset,
+ int char_offset,
GtkTextLineSegment **segment,
GtkTextLineSegment **any_segment,
- gint *seg_char_offset,
- gint *line_char_offset);
+ int *seg_char_offset,
+ int *line_char_offset);
void _gtk_text_line_byte_to_char_offsets (GtkTextLine *line,
- gint byte_offset,
- gint *line_char_offset,
- gint *seg_char_offset);
+ int byte_offset,
+ int *line_char_offset,
+ int *seg_char_offset);
void _gtk_text_line_char_to_byte_offsets (GtkTextLine *line,
- gint char_offset,
- gint *line_byte_offset,
- gint *seg_byte_offset);
+ int char_offset,
+ int *line_byte_offset,
+ int *seg_byte_offset);
GtkTextLineSegment *_gtk_text_line_byte_to_any_segment (GtkTextLine *line,
- gint byte_offset,
- gint *seg_offset);
+ int byte_offset,
+ int *seg_offset);
GtkTextLineSegment *_gtk_text_line_char_to_any_segment (GtkTextLine *line,
- gint char_offset,
- gint *seg_offset);
-gint _gtk_text_line_byte_to_char (GtkTextLine *line,
- gint byte_offset);
-gint _gtk_text_line_char_to_byte (GtkTextLine *line,
- gint char_offset);
+ int char_offset,
+ int *seg_offset);
+int _gtk_text_line_byte_to_char (GtkTextLine *line,
+ int byte_offset);
+int _gtk_text_line_char_to_byte (GtkTextLine *line,
+ int char_offset);
GtkTextLine * _gtk_text_line_next_could_contain_tag (GtkTextLine *line,
GtkTextBTree *tree,
GtkTextTag *tag);
GtkTextLine *line);
void _gtk_change_node_toggle_count (GtkTextBTreeNode *node,
GtkTextTagInfo *info,
- gint delta);
+ int delta);
/* for gtktextmark.c */
void _gtk_text_btree_release_mark_segment (GtkTextBTree *tree,
static void gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len);
+ int len);
static void gtk_text_buffer_real_insert_paintable (GtkTextBuffer *buffer,
GtkTextIter *iter,
GdkPaintable *paintable);
void
gtk_text_buffer_set_text (GtkTextBuffer *buffer,
const gchar *text,
- gint len)
+ int len)
{
GtkTextIter start, end;
gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len)
+ int len)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
gtk_text_buffer_emit_insert (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len)
+ int len)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
gtk_text_buffer_insert (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len)
+ int len)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
void
gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer,
const gchar *text,
- gint len)
+ int len)
{
GtkTextIter iter;
gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len,
+ int len,
gboolean default_editable)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
gboolean
gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer,
const gchar *text,
- gint len,
+ int len,
gboolean default_editable)
{
GtkTextIter iter;
while (TRUE)
{
- gint start_offset;
+ int start_offset;
GtkTextIter start_iter;
GSList *tags;
GSList *tmp_list;
gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len,
+ int len,
GtkTextTag *first_tag,
...)
{
- gint start_offset;
+ int start_offset;
GtkTextIter start;
va_list args;
GtkTextTag *tag;
gtk_text_buffer_insert_with_tags_by_name (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len,
+ int len,
const gchar *first_tag_name,
...)
{
- gint start_offset;
+ int start_offset;
GtkTextIter start;
va_list args;
const gchar *tag_name;
gtk_text_buffer_emit_tag (buffer, tag, FALSE, start, end);
}
-static gint
+static int
pointer_cmp (gconstpointer a,
gconstpointer b)
{
void
gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint line_number,
- gint char_offset)
+ int line_number,
+ int char_offset)
{
GtkTextIter end_line_iter;
void
gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint line_number,
- gint byte_index)
+ int line_number,
+ int byte_index)
{
GtkTextIter end_line_iter;
void
gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint line_number)
+ int line_number)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
void
gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint char_offset)
+ int char_offset)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
*
* Returns: number of lines in the buffer
**/
-gint
+int
gtk_text_buffer_get_line_count (GtkTextBuffer *buffer)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), 0);
*
* Returns: number of characters in the buffer
**/
-gint
+int
gtk_text_buffer_get_char_count (GtkTextBuffer *buffer)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), 0);
GtkTextIter end;
gboolean retval = FALSE;
const PangoLogAttr *attrs;
- gint offset;
+ int offset;
gboolean backspace_deletes_character;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
typedef struct _CacheEntry CacheEntry;
struct _CacheEntry
{
- gint line;
- gint char_len;
+ int line;
+ int char_len;
PangoLogAttr *attrs;
};
struct _GtkTextLogAttrCache
{
- gint chars_changed_stamp;
+ int chars_changed_stamp;
CacheEntry entries[ATTR_CACHE_SIZE];
};
static void
free_log_attr_cache (GtkTextLogAttrCache *cache)
{
- gint i;
+ int i;
for (i = 0; i < ATTR_CACHE_SIZE; i++)
g_free (cache->entries[i].attrs);
static void
clear_log_attr_cache (GtkTextLogAttrCache *cache)
{
- gint i;
+ int i;
for (i = 0; i < ATTR_CACHE_SIZE; i++)
{
static PangoLogAttr*
compute_log_attrs (const GtkTextIter *iter,
- gint *char_lenp)
+ int *char_lenp)
{
GtkTextIter start;
GtkTextIter end;
gchar *paragraph;
- gint char_len, byte_len;
+ int char_len, byte_len;
PangoLogAttr *attrs = NULL;
start = *iter;
const PangoLogAttr *
_gtk_text_buffer_get_line_log_attrs (GtkTextBuffer *buffer,
const GtkTextIter *anywhere_in_line,
- gint *char_len)
+ int *char_len)
{
GtkTextBufferPrivate *priv;
- gint line;
+ int line;
GtkTextLogAttrCache *cache;
- gint i;
+ int i;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (anywhere_in_line != NULL, NULL);
GtkTextIter *start,
GtkTextIter *end)
{
- gint line_number;
+ int line_number;
*start = *position;
*end = *start;
GtkTextIter *start,
GtkTextIter *end)
{
- gint line_number;
+ int line_number;
*start = *position;
*end = *start;
do
{
GtkTextTag *tag;
- gint start, end;
+ int start, end;
pango_attr_iterator_range (attr, &start, &end);
gtk_text_buffer_insert_markup (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *markup,
- gint len)
+ int len)
{
PangoAttrList *attributes;
gchar *text;
void (* insert_text) (GtkTextBuffer *buffer,
GtkTextIter *pos,
const gchar *new_text,
- gint new_text_length);
+ int new_text_length);
void (* insert_paintable) (GtkTextBuffer *buffer,
GtkTextIter *iter,
GDK_AVAILABLE_IN_ALL
GtkTextBuffer *gtk_text_buffer_new (GtkTextTagTable *table);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_buffer_get_line_count (GtkTextBuffer *buffer);
+int gtk_text_buffer_get_line_count (GtkTextBuffer *buffer);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_buffer_get_char_count (GtkTextBuffer *buffer);
+int gtk_text_buffer_get_char_count (GtkTextBuffer *buffer);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_set_text (GtkTextBuffer *buffer,
const gchar *text,
- gint len);
+ int len);
/* Insert into the buffer */
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_insert (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len);
+ int len);
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer,
const gchar *text,
- gint len);
+ int len);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len,
+ int len,
gboolean default_editable);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_buffer_insert_interactive_at_cursor (GtkTextBuffer *buffer,
const gchar *text,
- gint len,
+ int len,
gboolean default_editable);
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len,
+ int len,
GtkTextTag *first_tag,
...) G_GNUC_NULL_TERMINATED;
void gtk_text_buffer_insert_with_tags_by_name (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *text,
- gint len,
+ int len,
const gchar *first_tag_name,
...) G_GNUC_NULL_TERMINATED;
void gtk_text_buffer_insert_markup (GtkTextBuffer *buffer,
GtkTextIter *iter,
const gchar *markup,
- gint len);
+ int len);
/* Delete from the buffer */
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint line_number,
- gint char_offset);
+ int line_number,
+ int char_offset);
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint line_number,
- gint byte_index);
+ int line_number,
+ int byte_index);
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint char_offset);
+ int char_offset);
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
GtkTextIter *iter,
- gint line_number);
+ int line_number);
GDK_AVAILABLE_IN_ALL
void gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer,
GtkTextIter *iter);
const PangoLogAttr* _gtk_text_buffer_get_line_log_attrs (GtkTextBuffer *buffer,
const GtkTextIter *anywhere_in_line,
- gint *char_len);
+ int *char_len);
void _gtk_text_buffer_notify_will_remove_tag (GtkTextBuffer *buffer,
GtkTextTag *tag);
GdkRectangle pointing_to;
GtkBorder border;
- gint dx;
- gint dy;
+ int dx;
+ int dy;
guint role : 2;
guint dragged : 1;
guint mode_visible : 1;
{
GtkTextHandle *handle = GTK_TEXT_HANDLE (widget);
gdouble start_x, start_y;
- gint x, y;
+ int x, y;
gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
If the line byte offset is valid, so is the segment byte offset;
and ditto for char offsets. */
- gint line_byte_offset;
- gint line_char_offset;
+ int line_byte_offset;
+ int line_char_offset;
/* These two are valid if >= 0 */
- gint cached_char_index;
- gint cached_line_number;
+ int cached_char_index;
+ int cached_line_number;
/* Stamps to detect the buffer changing under us */
- gint chars_changed_stamp;
- gint segments_changed_stamp;
+ int chars_changed_stamp;
+ int segments_changed_stamp;
/* Valid if the segments_changed_stamp is up-to-date */
GtkTextLineSegment *segment; /* indexable segment we index */
GtkTextLineSegment *any_segment; /* first segment in our location,
If the line byte offset is valid, so is the segment byte offset;
and ditto for char offsets. */
- gint segment_byte_offset;
- gint segment_char_offset;
+ int segment_byte_offset;
+ int segment_char_offset;
/* padding */
- gint pad1;
+ int pad1;
gpointer pad2;
};
static void
iter_set_from_byte_offset (GtkTextRealIter *iter,
GtkTextLine *line,
- gint byte_offset)
+ int byte_offset)
{
iter_set_common (iter, line);
static void
iter_set_from_char_offset (GtkTextRealIter *iter,
GtkTextLine *line,
- gint char_offset)
+ int char_offset)
{
iter_set_common (iter, line);
GtkTextLineSegment *segment)
{
GtkTextLineSegment *seg;
- gint byte_offset;
+ int byte_offset;
/* This could theoretically be optimized by computing all the iter
fields in this same loop, but I'm skipping it for now. */
iter_init_from_byte_offset (GtkTextIter *iter,
GtkTextBTree *tree,
GtkTextLine *line,
- gint line_byte_offset)
+ int line_byte_offset)
{
GtkTextRealIter *real;
iter_init_from_char_offset (GtkTextIter *iter,
GtkTextBTree *tree,
GtkTextLine *line,
- gint line_char_offset)
+ int line_char_offset)
{
GtkTextRealIter *real;
}
static inline void
-adjust_char_index (GtkTextRealIter *iter, gint count)
+adjust_char_index (GtkTextRealIter *iter, int count)
{
if (iter->cached_char_index >= 0)
iter->cached_char_index += count;
}
static inline void
-adjust_line_number (GtkTextRealIter *iter, gint count)
+adjust_line_number (GtkTextRealIter *iter, int count)
{
if (iter->cached_line_number >= 0)
iter->cached_line_number += count;
return real->any_segment;
}
-gint
+int
_gtk_text_iter_get_segment_byte (const GtkTextIter *iter)
{
GtkTextRealIter *real;
return real->segment_byte_offset;
}
-gint
+int
_gtk_text_iter_get_segment_char (const GtkTextIter *iter)
{
GtkTextRealIter *real;
*
* Returns: a character offset
**/
-gint
+int
gtk_text_iter_get_offset (const GtkTextIter *iter)
{
GtkTextRealIter *real;
*
* Returns: a line number
**/
-gint
+int
gtk_text_iter_get_line (const GtkTextIter *iter)
{
GtkTextRealIter *real;
*
* Returns: offset from start of line
**/
-gint
+int
gtk_text_iter_get_line_offset (const GtkTextIter *iter)
{
GtkTextRealIter *real;
*
* Returns: distance from start of line, in bytes
**/
-gint
+int
gtk_text_iter_get_line_index (const GtkTextIter *iter)
{
GtkTextRealIter *real;
*
* Returns: offset in visible characters from the start of the line
**/
-gint
+int
gtk_text_iter_get_visible_line_offset (const GtkTextIter *iter)
{
GtkTextRealIter *real;
- gint vis_offset;
+ int vis_offset;
GtkTextLineSegment *seg;
GtkTextIter pos;
*
* Returns: byte index of @iter with respect to the start of the line
**/
-gint
+int
gtk_text_iter_get_visible_line_index (const GtkTextIter *iter)
{
GtkTextRealIter *real;
- gint vis_offset;
+ int vis_offset;
GtkTextLineSegment *seg;
GtkTextIter pos;
gtk_text_iter_get_tags (const GtkTextIter *iter)
{
GtkTextTag** tags;
- gint tag_count = 0;
- gint i;
+ int tag_count = 0;
+ int i;
GSList *retval;
g_return_val_if_fail (iter != NULL, NULL);
GtkTextAttributes *values)
{
GtkTextTag** tags;
- gint tag_count = 0;
+ int tag_count = 0;
/* Get the tags at this spot */
tags = _gtk_text_btree_get_tags (iter, &tag_count);
*
* Returns: number of characters in the line
**/
-gint
+int
gtk_text_iter_get_chars_in_line (const GtkTextIter *iter)
{
GtkTextRealIter *real;
- gint count;
+ int count;
GtkTextLineSegment *seg;
g_return_val_if_fail (iter != NULL, 0);
*
* Returns: number of bytes in the line
**/
-gint
+int
gtk_text_iter_get_bytes_in_line (const GtkTextIter *iter)
{
GtkTextRealIter *real;
- gint count;
+ int count;
GtkTextLineSegment *seg;
g_return_val_if_fail (iter != NULL, 0);
if (real->line_byte_offset >= 0)
{
- gint bytes;
+ int bytes;
const char * start =
real->segment->body.chars + real->segment_byte_offset;
GtkTextLineSegment *seg;
GtkTextLineSegment *any_seg;
GtkTextRealIter *real;
- gint chars_skipped;
- gint bytes_skipped;
+ int chars_skipped;
+ int bytes_skipped;
g_return_val_if_fail (iter != NULL, FALSE);
GtkTextLineSegment *any_seg;
GtkTextLineSegment *prev_seg;
GtkTextLineSegment *prev_any_seg;
- gint bytes_skipped;
- gint chars_skipped;
+ int bytes_skipped;
+ int chars_skipped;
g_return_val_if_fail (iter != NULL, FALSE);
* Returns: whether @iter moved and is dereferenceable
**/
gboolean
-gtk_text_iter_forward_chars (GtkTextIter *iter, gint count)
+gtk_text_iter_forward_chars (GtkTextIter *iter, int count)
{
GtkTextRealIter *real;
}
else
{
- gint current_char_index;
- gint new_char_index;
+ int current_char_index;
+ int new_char_index;
check_invariants (iter);
*
**/
gboolean
-gtk_text_iter_backward_chars (GtkTextIter *iter, gint count)
+gtk_text_iter_backward_chars (GtkTextIter *iter, int count)
{
GtkTextRealIter *real;
if (real->line_byte_offset >= 0)
{
const char *p;
- gint new_byte_offset;
+ int new_byte_offset;
/* if in the last fourth of the segment walk backwards */
if (count < real->segment_char_offset / 4)
*/
if (TRUE || count > MAX_LINEAR_SCAN)
{
- gint current_char_index;
- gint new_char_index;
+ int current_char_index;
+ int new_char_index;
current_char_index = gtk_text_iter_get_offset (iter);
**/
gboolean
gtk_text_iter_forward_text_chars (GtkTextIter *iter,
- gint count)
+ int count)
{
**/
gboolean
gtk_text_iter_backward_text_chars (GtkTextIter *iter,
- gint count)
+ int count)
{
GtkTextLine *new_line;
GtkTextRealIter *real;
gboolean offset_will_change;
- gint offset;
+ int offset;
g_return_val_if_fail (iter != NULL, FALSE);
* Returns: whether @iter moved and is dereferenceable
**/
gboolean
-gtk_text_iter_forward_lines (GtkTextIter *iter, gint count)
+gtk_text_iter_forward_lines (GtkTextIter *iter, int count)
{
FIX_OVERFLOWS (count);
}
else
{
- gint old_line;
+ int old_line;
if (gtk_text_iter_is_end (iter))
return FALSE;
* Returns: whether @iter moved and is dereferenceable
**/
gboolean
-gtk_text_iter_backward_lines (GtkTextIter *iter, gint count)
+gtk_text_iter_backward_lines (GtkTextIter *iter, int count)
{
FIX_OVERFLOWS (count);
}
else
{
- gint old_line;
+ int old_line;
old_line = gtk_text_iter_get_line (iter);
**/
gboolean
gtk_text_iter_forward_visible_lines (GtkTextIter *iter,
- gint count)
+ int count)
{
FIX_OVERFLOWS (count);
**/
gboolean
gtk_text_iter_backward_visible_lines (GtkTextIter *iter,
- gint count)
+ int count)
{
FIX_OVERFLOWS (count);
}
typedef gboolean (* FindLogAttrFunc) (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially);
typedef gboolean (* TestLogAttrFunc) (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len);
+ int offset,
+ int min_offset,
+ int len);
/* Word funcs */
static gboolean
find_word_end_func (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially)
{
if (!already_moved_initially)
static gboolean
is_word_end_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
return attrs[offset].is_word_end;
}
static gboolean
find_word_start_func (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially)
{
if (!already_moved_initially)
static gboolean
is_word_start_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
return attrs[offset].is_word_start;
}
static gboolean
inside_word_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
/* Find next word start or end */
while (offset >= min_offset &&
static gboolean
find_sentence_end_func (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially)
{
if (!already_moved_initially)
static gboolean
is_sentence_end_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
return attrs[offset].is_sentence_end;
}
static gboolean
find_sentence_start_func (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially)
{
if (!already_moved_initially)
static gboolean
is_sentence_start_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
return attrs[offset].is_sentence_start;
}
static gboolean
inside_sentence_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
/* Find next sentence start or end */
while (!(attrs[offset].is_sentence_start || attrs[offset].is_sentence_end))
test_log_attrs (const GtkTextIter *iter,
TestLogAttrFunc func)
{
- gint char_len;
+ int char_len;
const PangoLogAttr *attrs;
- gint offset;
+ int offset;
g_return_val_if_fail (iter != NULL, FALSE);
static gboolean
find_line_log_attrs (const GtkTextIter *iter,
FindLogAttrFunc func,
- gint *found_offset,
+ int *found_offset,
gboolean already_moved_initially)
{
- gint char_len;
+ int char_len;
const PangoLogAttr *attrs;
- gint offset;
+ int offset;
g_return_val_if_fail (iter != NULL, FALSE);
while (TRUE)
{
- gint offset = 0;
+ int offset = 0;
gboolean found;
found = find_line_log_attrs (&iter, func, &offset, already_moved_initially);
}
typedef gboolean (* OneStepFunc) (GtkTextIter *iter);
-typedef gboolean (* MultipleStepFunc) (GtkTextIter *iter, gint count);
+typedef gboolean (* MultipleStepFunc) (GtkTextIter *iter, int count);
static gboolean
move_multiple_steps (GtkTextIter *iter,
- gint count,
+ int count,
OneStepFunc step_forward,
MultipleStepFunc n_steps_backward)
{
**/
gboolean
gtk_text_iter_forward_word_ends (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_forward_word_end,
**/
gboolean
gtk_text_iter_backward_word_starts (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_backward_word_start,
**/
gboolean
gtk_text_iter_forward_visible_word_ends (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_forward_visible_word_end,
**/
gboolean
gtk_text_iter_backward_visible_word_starts (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_backward_visible_word_start,
**/
gboolean
gtk_text_iter_forward_sentence_ends (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_forward_sentence_end,
**/
gboolean
gtk_text_iter_backward_sentence_starts (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_backward_sentence_start,
static gboolean
find_forward_cursor_pos_func (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially)
{
if (!already_moved_initially)
static gboolean
find_backward_cursor_pos_func (const PangoLogAttr *attrs,
- gint offset,
- gint len,
- gint *found_offset,
+ int offset,
+ int len,
+ int *found_offset,
gboolean already_moved_initially)
{
if (!already_moved_initially)
static gboolean
is_cursor_pos_func (const PangoLogAttr *attrs,
- gint offset,
- gint min_offset,
- gint len)
+ int offset,
+ int min_offset,
+ int len)
{
return attrs[offset].is_cursor_position;
}
**/
gboolean
gtk_text_iter_forward_cursor_positions (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_forward_cursor_position,
**/
gboolean
gtk_text_iter_backward_cursor_positions (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_backward_cursor_position,
**/
gboolean
gtk_text_iter_forward_visible_cursor_positions (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_forward_visible_cursor_position,
**/
gboolean
gtk_text_iter_backward_visible_cursor_positions (GtkTextIter *iter,
- gint count)
+ int count)
{
return move_multiple_steps (iter, count,
gtk_text_iter_backward_visible_cursor_position,
**/
void
gtk_text_iter_set_line_offset (GtkTextIter *iter,
- gint char_on_line)
+ int char_on_line)
{
GtkTextRealIter *real;
- gint chars_in_line;
+ int chars_in_line;
g_return_if_fail (iter != NULL);
**/
void
gtk_text_iter_set_line_index (GtkTextIter *iter,
- gint byte_on_line)
+ int byte_on_line)
{
GtkTextRealIter *real;
- gint bytes_in_line;
+ int bytes_in_line;
g_return_if_fail (iter != NULL);
**/
void
gtk_text_iter_set_visible_line_offset (GtkTextIter *iter,
- gint char_on_line)
+ int char_on_line)
{
- gint chars_seen = 0;
+ int chars_seen = 0;
GtkTextIter pos;
g_return_if_fail (iter != NULL);
**/
void
gtk_text_iter_set_visible_line_index (GtkTextIter *iter,
- gint byte_on_line)
+ int byte_on_line)
{
GtkTextRealIter *real;
- gint offset = 0;
+ int offset = 0;
GtkTextIter pos;
GtkTextLineSegment *seg;
**/
void
gtk_text_iter_set_line (GtkTextIter *iter,
- gint line_number)
+ int line_number)
{
GtkTextLine *line;
- gint real_line;
+ int real_line;
GtkTextRealIter *real;
g_return_if_fail (iter != NULL);
**/
void
gtk_text_iter_set_offset (GtkTextIter *iter,
- gint char_offset)
+ int char_offset)
{
GtkTextLine *line;
GtkTextRealIter *real;
- gint line_start;
- gint real_char_index;
+ int line_start;
+ int real_char_index;
g_return_if_fail (iter != NULL);
gboolean
gtk_text_iter_forward_to_line_end (GtkTextIter *iter)
{
- gint current_offset;
- gint new_offset;
+ int current_offset;
+ int new_offset;
g_return_val_if_fail (iter != NULL, FALSE);
GtkTextCharPredicate pred,
gpointer user_data)
{
- gint ch;
+ int ch;
ch = gtk_text_iter_get_char (iter);
static void
forward_chars_with_skipping (GtkTextIter *iter,
- gint count,
+ int count,
gboolean skip_invisible,
gboolean skip_nontext,
gboolean skip_decomp)
{
- gint i;
+ int i;
g_return_if_fail (count >= 0);
gchar *normal;
gchar *casefold;
gchar buffer[6];
- gint buffer_len;
+ int buffer_len;
buffer_len = g_unichar_to_utf8 (gtk_text_iter_get_char (iter), buffer);
casefold = g_utf8_casefold (buffer, buffer_len);
static const gchar *
pointer_from_offset_skipping_decomp (const gchar *str,
- gint offset)
+ int offset)
{
gchar *casefold, *normal;
const gchar *p, *q;
gchar *p;
gchar *casefold;
gchar *caseless_haystack;
- gint i;
+ int i;
g_return_val_if_fail (haystack != NULL, NULL);
g_return_val_if_fail (needle != NULL, NULL);
gchar *p;
gchar *casefold;
gchar *caseless_haystack;
- gint i;
+ int i;
g_return_val_if_fail (haystack != NULL, NULL);
g_return_val_if_fail (needle != NULL, NULL);
gchar *casefold;
gchar *normalized_s1;
gchar *normalized_s2;
- gint len_s1;
- gint len_s2;
+ int len_s1;
+ int len_s2;
gboolean ret = FALSE;
g_return_val_if_fail (s1 != NULL, FALSE);
GtkTextIter next;
gchar *line_text;
const gchar *found;
- gint offset;
+ int offset;
if (*lines == NULL || **lines == '\0')
{
static gchar **
strbreakup (const char *string,
const char *delimiter,
- gint max_tokens,
- gint *num_strings,
+ int max_tokens,
+ int *num_strings,
gboolean case_insensitive)
{
GSList *string_list = NULL, *slist;
while (*i1 && *i2)
{
- gint len1;
- gint len2;
+ int len1;
+ int len2;
if (!case_insensitive)
{
struct _LinesWindow
{
- gint n_lines;
+ int n_lines;
gchar **lines;
GtkTextIter first_line_start;
lines_window_init (LinesWindow *win,
const GtkTextIter *start)
{
- gint i;
+ int i;
GtkTextIter line_start;
GtkTextIter line_end;
{
gchar **lines = NULL;
gchar **l;
- gint n_lines;
+ int n_lines;
LinesWindow win;
gboolean retval = FALSE;
gboolean visible_only;
case_insensitive))
{
/* Match! */
- gint offset;
+ int offset;
GtkTextIter start_tmp;
GtkTextIter end_tmp;
*
* Returns: -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
**/
-gint
+int
gtk_text_iter_compare (const GtkTextIter *lhs,
const GtkTextIter *rhs)
{
if (real_lhs->line == real_rhs->line)
{
- gint left_index, right_index;
+ int left_index, right_index;
if (real_lhs->line_byte_offset >= 0 &&
real_rhs->line_byte_offset >= 0)
}
else
{
- gint line1, line2;
+ int line1, line2;
line1 = gtk_text_iter_get_line (lhs);
line2 = gtk_text_iter_get_line (rhs);
void
_gtk_text_btree_get_iter_at_char (GtkTextBTree *tree,
GtkTextIter *iter,
- gint char_index)
+ int char_index)
{
GtkTextRealIter *real = (GtkTextRealIter*)iter;
- gint real_char_index;
- gint line_start;
+ int real_char_index;
+ int line_start;
GtkTextLine *line;
g_return_if_fail (iter != NULL);
void
_gtk_text_btree_get_iter_at_line_char (GtkTextBTree *tree,
GtkTextIter *iter,
- gint line_number,
- gint char_on_line)
+ int line_number,
+ int char_on_line)
{
GtkTextRealIter *real = (GtkTextRealIter*)iter;
GtkTextLine *line;
- gint real_line;
+ int real_line;
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
void
_gtk_text_btree_get_iter_at_line_byte (GtkTextBTree *tree,
GtkTextIter *iter,
- gint line_number,
- gint byte_index)
+ int line_number,
+ int byte_index)
{
GtkTextRealIter *real = (GtkTextRealIter*)iter;
GtkTextLine *line;
- gint real_line;
+ int real_line;
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
_gtk_text_btree_get_iter_at_line (GtkTextBTree *tree,
GtkTextIter *iter,
GtkTextLine *line,
- gint byte_offset)
+ int byte_offset)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (tree != NULL);
_gtk_text_iter_check (const GtkTextIter *iter)
{
const GtkTextRealIter *real = (const GtkTextRealIter*)iter;
- gint line_char_offset, line_byte_offset, seg_char_offset, seg_byte_offset;
+ int line_char_offset, line_byte_offset, seg_char_offset, seg_byte_offset;
GtkTextLineSegment *byte_segment = NULL;
GtkTextLineSegment *byte_any_segment = NULL;
GtkTextLineSegment *char_segment = NULL;
segment. */
if (char_segment->type == >k_text_char_type)
{
- gint byte_offset = 0;
- gint char_offset = 0;
+ int byte_offset = 0;
+ int char_offset = 0;
while (char_offset < seg_char_offset)
{
const char * start = char_segment->body.chars + byte_offset;
if (real->cached_line_number >= 0)
{
- gint should_be;
+ int should_be;
should_be = _gtk_text_line_get_number (real->line);
if (real->cached_line_number != should_be)
efficiently, not a real
invariant. */
{
- gint char_index;
+ int char_index;
char_index = _gtk_text_line_char_index (real->line);
char_index += real->line_char_offset;
/*< private >*/
gpointer dummy1;
gpointer dummy2;
- gint dummy3;
- gint dummy4;
- gint dummy5;
- gint dummy6;
- gint dummy7;
- gint dummy8;
+ int dummy3;
+ int dummy4;
+ int dummy5;
+ int dummy6;
+ int dummy7;
+ int dummy8;
gpointer dummy9;
gpointer dummy10;
- gint dummy11;
- gint dummy12;
+ int dummy11;
+ int dummy12;
/* padding */
- gint dummy13;
+ int dummy13;
gpointer dummy14;
};
*/
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_offset (const GtkTextIter *iter);
+int gtk_text_iter_get_offset (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_line (const GtkTextIter *iter);
+int gtk_text_iter_get_line (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_line_offset (const GtkTextIter *iter);
+int gtk_text_iter_get_line_offset (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_line_index (const GtkTextIter *iter);
+int gtk_text_iter_get_line_index (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_visible_line_offset (const GtkTextIter *iter);
+int gtk_text_iter_get_visible_line_offset (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_visible_line_index (const GtkTextIter *iter);
+int gtk_text_iter_get_visible_line_index (const GtkTextIter *iter);
/*
gboolean gtk_text_iter_is_cursor_position (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_chars_in_line (const GtkTextIter *iter);
+int gtk_text_iter_get_chars_in_line (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_get_bytes_in_line (const GtkTextIter *iter);
+int gtk_text_iter_get_bytes_in_line (const GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
PangoLanguage* gtk_text_iter_get_language (const GtkTextIter *iter);
gboolean gtk_text_iter_backward_char (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_chars (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_chars (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_line (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_line (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_lines (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_lines (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_word_end (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_word_start (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_word_ends (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_word_starts (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_visible_line (GtkTextIter *iter);
gboolean gtk_text_iter_backward_visible_line (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_visible_lines (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_visible_lines (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_visible_word_end (GtkTextIter *iter);
gboolean gtk_text_iter_backward_visible_word_start (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_visible_word_ends (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_visible_word_starts (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_sentence_end (GtkTextIter *iter);
gboolean gtk_text_iter_backward_sentence_start (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_sentence_ends (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_sentence_starts (GtkTextIter *iter,
- gint count);
+ int count);
/* cursor positions are almost equivalent to chars, but not quite;
* in some languages, you can’t put the cursor between certain
* chars. Also, you can’t put the cursor between \r\n at the end
gboolean gtk_text_iter_backward_cursor_position (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_cursor_positions (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_cursor_positions (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_visible_cursor_position (GtkTextIter *iter);
gboolean gtk_text_iter_backward_visible_cursor_position (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_forward_visible_cursor_positions (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_backward_visible_cursor_positions (GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_set_offset (GtkTextIter *iter,
- gint char_offset);
+ int char_offset);
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_set_line (GtkTextIter *iter,
- gint line_number);
+ int line_number);
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_set_line_offset (GtkTextIter *iter,
- gint char_on_line);
+ int char_on_line);
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_set_line_index (GtkTextIter *iter,
- gint byte_on_line);
+ int byte_on_line);
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_forward_to_end (GtkTextIter *iter);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_set_visible_line_offset (GtkTextIter *iter,
- gint char_on_line);
+ int char_on_line);
GDK_AVAILABLE_IN_ALL
void gtk_text_iter_set_visible_line_index (GtkTextIter *iter,
- gint byte_on_line);
+ int byte_on_line);
/* returns TRUE if a toggle was found; NULL for the tag pointer
* means “any tag toggle”, otherwise the next toggle of the
gboolean gtk_text_iter_equal (const GtkTextIter *lhs,
const GtkTextIter *rhs);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_iter_compare (const GtkTextIter *lhs,
+int gtk_text_iter_compare (const GtkTextIter *lhs,
const GtkTextIter *rhs);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_iter_in_range (const GtkTextIter *iter,
GtkTextBTree * _gtk_text_iter_get_btree (const GtkTextIter *iter);
gboolean _gtk_text_iter_forward_indexable_segment (GtkTextIter *iter);
gboolean _gtk_text_iter_backward_indexable_segment (GtkTextIter *iter);
-gint _gtk_text_iter_get_segment_byte (const GtkTextIter *iter);
-gint _gtk_text_iter_get_segment_char (const GtkTextIter *iter);
+int _gtk_text_iter_get_segment_byte (const GtkTextIter *iter);
+int _gtk_text_iter_get_segment_char (const GtkTextIter *iter);
gboolean _gtk_text_iter_same_line (const GtkTextIter *lhs,
const GtkTextIter *rhs);
static void gtk_text_layout_invalidate_cursor_line (GtkTextLayout *layout,
gboolean cursors_only);
static void gtk_text_layout_emit_changed (GtkTextLayout *layout,
- gint y,
- gint old_height,
- gint new_height);
+ int y,
+ int old_height,
+ int new_height);
static void gtk_text_layout_invalidate_all (GtkTextLayout *layout);
static void gtk_text_layout_after_buffer_insert_text (GtkTextBuffer *textbuffer,
GtkTextIter *iter,
gchar *str,
- gint len,
+ int len,
gpointer data);
static void gtk_text_layout_after_buffer_delete_range (GtkTextBuffer *textbuffer,
GtkTextIter *start,
static void gtk_text_layout_before_buffer_insert_text (GtkTextBuffer *textbuffer,
GtkTextIter *iter,
gchar *str,
- gint len,
+ int len,
gpointer data);
static void gtk_text_layout_before_buffer_delete_range (GtkTextBuffer *textbuffer,
GtkTextIter *start,
gpointer data);
-static void gtk_text_layout_update_cursor_line (GtkTextLayout *layout);
+static void gtk_text_layout_update_cursor_line (GtkTextLayout *layout);
-static void line_display_index_to_iter (GtkTextLayout *layout,
- GtkTextLineDisplay *display,
- GtkTextIter *iter,
- gint index,
- gint trailing);
+static void line_display_index_to_iter (GtkTextLayout *layout,
+ GtkTextLineDisplay*display,
+ GtkTextIter *iter,
+ int index,
+ int trailing);
-static gint line_display_iter_to_index (GtkTextLayout *layout,
- GtkTextLineDisplay *display,
- const GtkTextIter *iter);
+static int line_display_iter_to_index (GtkTextLayout *layout,
+ GtkTextLineDisplay*display,
+ const GtkTextIter *iter);
enum {
INVALIDATED,
}
void
-gtk_text_layout_set_screen_width (GtkTextLayout *layout, gint width)
+gtk_text_layout_set_screen_width (GtkTextLayout *layout, int width)
{
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
g_return_if_fail (width >= 0);
if (layout->cursor_visible != cursor_visible)
{
GtkTextIter iter;
- gint y, height;
+ int y, height;
layout->cursor_visible = cursor_visible;
gtk_text_layout_set_preedit_string (GtkTextLayout *layout,
const gchar *preedit_string,
PangoAttrList *preedit_attrs,
- gint cursor_pos)
+ int cursor_pos)
{
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
g_return_if_fail (preedit_attrs != NULL || preedit_string == NULL);
void
gtk_text_layout_get_size (GtkTextLayout *layout,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
static void
gtk_text_layout_emit_changed (GtkTextLayout *layout,
- gint y,
- gint old_height,
- gint new_height)
+ int y,
+ int old_height,
+ int new_height)
{
g_signal_emit (layout, signals[CHANGED], 0, y, old_height, new_height);
}
void
gtk_text_layout_changed (GtkTextLayout *layout,
- gint y,
- gint old_height,
- gint new_height)
+ int y,
+ int old_height,
+ int new_height)
{
GtkTextLayoutPrivate *priv = GTK_TEXT_LAYOUT_GET_PRIVATE (layout);
gtk_text_line_display_cache_invalidate_y_range (priv->cache, layout, y, old_height, FALSE);
void
gtk_text_layout_cursors_changed (GtkTextLayout *layout,
- gint y,
- gint old_height,
- gint new_height)
+ int y,
+ int old_height,
+ int new_height)
{
GtkTextLayoutPrivate *priv = GTK_TEXT_LAYOUT_GET_PRIVATE (layout);
gtk_text_line_display_cache_invalidate_y_range (priv->cache, layout, y, old_height, TRUE);
GSList*
gtk_text_layout_get_lines (GtkTextLayout *layout,
/* [top_y, bottom_y) */
- gint top_y,
- gint bottom_y,
- gint *first_line_y)
+ int top_y,
+ int bottom_y,
+ int *first_line_y)
{
GtkTextLine *first_btree_line;
GtkTextLine *last_btree_line;
void
gtk_text_layout_validate_yrange (GtkTextLayout *layout,
GtkTextIter *anchor,
- gint y0,
- gint y1)
+ int y0,
+ int y1)
{
GtkTextLine *line;
GtkTextLine *first_line = NULL;
GtkTextLine *last_line = NULL;
- gint seen;
- gint delta_height = 0;
- gint first_line_y = 0; /* Quiet GCC */
- gint last_line_y = 0; /* Quiet GCC */
+ int seen;
+ int delta_height = 0;
+ int first_line_y = 0; /* Quiet GCC */
+ int last_line_y = 0; /* Quiet GCC */
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
GtkTextLineData *line_data = _gtk_text_line_get_data (line, layout);
if (!line_data || !line_data->valid)
{
- gint old_height, new_height;
- gint top_ink, bottom_ink;
+ int old_height, new_height;
+ int top_ink, bottom_ink;
old_height = line_data ? line_data->height : 0;
top_ink = line_data ? line_data->top_ink : 0;
GtkTextLineData *line_data = _gtk_text_line_get_data (line, layout);
if (!line_data || !line_data->valid)
{
- gint old_height, new_height;
- gint top_ink, bottom_ink;
+ int old_height, new_height;
+ int top_ink, bottom_ink;
old_height = line_data ? line_data->height : 0;
top_ink = line_data ? line_data->top_ink : 0;
*/
if (first_line)
{
- gint line_top;
+ int line_top;
update_layout_size (layout);
**/
void
gtk_text_layout_validate (GtkTextLayout *layout,
- gint max_pixels)
+ int max_pixels)
{
- gint y, old_height, new_height;
+ int y, old_height, new_height;
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
{
PangoAlignment pango_align = PANGO_ALIGN_LEFT;
PangoWrapMode pango_wrap = PANGO_WRAP_WORD;
- gint h_margin;
- gint h_padding;
+ int h_margin;
+ int h_padding;
switch (base_dir)
{
static void
add_generic_attrs (GtkTextLayout *layout,
GtkTextAppearance *appearance,
- gint byte_count,
+ int byte_count,
PangoAttrList *attrs,
- gint start,
+ int start,
gboolean size_only,
gboolean is_text)
{
static void
add_text_attrs (GtkTextLayout *layout,
GtkTextAttributes *style,
- gint byte_count,
+ int byte_count,
PangoAttrList *attrs,
- gint start,
+ int start,
gboolean size_only,
PangoAttribute **last_font_attr,
PangoAttribute **last_scale_attr,
GtkTextAttributes *style,
GtkTextLineSegment *seg,
PangoAttrList *attrs,
- gint start)
+ int start)
{
PangoAttribute *attr;
PangoRectangle logical_rect;
GtkTextPaintable *paintable = &seg->body.paintable;
- gint width, height;
+ int width, height;
width = gdk_paintable_get_intrinsic_width (paintable->paintable);
height = gdk_paintable_get_intrinsic_height (paintable->paintable);
GtkTextAttributes *style,
GtkTextLineSegment *seg,
PangoAttrList *attrs,
- gint start)
+ int start)
{
PangoAttribute *attr;
PangoRectangle logical_rect;
- gint width, height;
+ int width, height;
GSList *tmp_list;
GtkWidget *widget = NULL;
get_block_cursor (GtkTextLayout *layout,
GtkTextLineDisplay *display,
const GtkTextIter *insert_iter,
- gint insert_index,
+ int insert_index,
GdkRectangle *pos,
gboolean *cursor_at_line_end)
{
add_cursor (GtkTextLayout *layout,
GtkTextLineDisplay *display,
GtkTextLineSegment *seg,
- gint start)
+ int start)
{
CursorPosition cursor;
if (run && is_shape (run))
{
- gint byte_index;
+ int byte_index;
GtkTextIter text_iter;
GtkTextChildAnchor *anchor = NULL;
GtkWidget **widgets = NULL;
add_preedit_attrs (GtkTextLayout *layout,
GtkTextAttributes *style,
PangoAttrList *attrs,
- gint offset,
+ int offset,
gboolean size_only)
{
PangoAttrIterator *iter = pango_attr_list_get_iterator (layout->preedit_attrs);
GSList *extra_attrs = NULL;
GSList *tmp_list;
PangoLanguage *language;
- gint start, end;
+ int start, end;
pango_attr_iterator_range (iter, &start, &end);
{
GtkTextLineSegment *seg;
GtkTextIter iter;
- gint layout_byte_offset, buffer_byte_offset;
+ int layout_byte_offset, buffer_byte_offset;
GSList *cursor_byte_offsets = NULL;
GSList *cursor_segs = NULL;
GSList *tmp_list1, *tmp_list2;
else if (seg->type == >k_text_right_mark_type ||
seg->type == >k_text_left_mark_type)
{
- gint cursor_offset = 0;
+ int cursor_offset = 0;
/* At the insertion point, add the preedit string, if any */
{
GtkTextTag **tags;
GPtrArray *array = NULL;
- gint n_tags;
+ int n_tags;
tags = _gtk_text_btree_get_tags (iter, &n_tags);
tags_array_toggle_tag (GPtrArray *array,
GtkTextTag *tag)
{
- gint pos;
+ int pos;
GtkTextTag **tags;
if (array == NULL)
GtkTextIter iter;
GtkTextAttributes *style;
gchar *text;
- gint text_pixel_width;
+ int text_pixel_width;
PangoAttrList *attrs;
- gint text_allocated, layout_byte_offset, buffer_byte_offset;
+ int text_allocated, layout_byte_offset, buffer_byte_offset;
PangoRectangle extents;
gboolean para_values_set = FALSE;
GSList *cursor_byte_offsets = NULL;
PangoDirection base_dir;
GPtrArray *tags;
gboolean initial_toggle_segments;
- gint h_margin;
- gint h_padding;
+ int h_margin;
+ int h_padding;
PangoAttribute *last_font_attr = NULL;
PangoAttribute *last_scale_attr = NULL;
PangoAttribute *last_fallback_attr = NULL;
* if there are toggles in-between
*/
- gint bytes = 0;
+ int bytes = 0;
GtkTextLineSegment *prev_seg = NULL;
while (seg)
else if (seg->type == >k_text_right_mark_type ||
seg->type == >k_text_left_mark_type)
{
- gint cursor_offset = 0;
+ int cursor_offset = 0;
/* At the insertion point, add the preedit string, if any */
*/
if (pango_layout_get_width (display->layout) < 0)
{
- gint excess = display->total_width - text_pixel_width;
+ int excess = display->total_width - text_pixel_width;
switch (pango_layout_get_alignment (display->layout))
{
/* Functions to convert iter <=> index for the line of a GtkTextLineDisplay
* taking into account the preedit string and invisible text if necessary.
*/
-static gint
+static int
line_display_iter_to_index (GtkTextLayout *layout,
GtkTextLineDisplay *display,
const GtkTextIter *iter)
{
- gint index;
+ int index;
g_return_val_if_fail (_gtk_text_iter_get_text_line (iter) == display->line, 0);
line_display_index_to_iter (GtkTextLayout *layout,
GtkTextLineDisplay *display,
GtkTextIter *iter,
- gint index,
- gint trailing)
+ int index,
+ int trailing)
{
g_return_if_fail (!_gtk_text_line_is_last (display->line,
_gtk_text_buffer_get_btree (layout->buffer)));
static void
get_line_at_y (GtkTextLayout *layout,
- gint y,
+ int y,
GtkTextLine **line,
- gint *line_top)
+ int *line_top)
{
if (y < 0)
y = 0;
void
gtk_text_layout_get_line_at_y (GtkTextLayout *layout,
GtkTextIter *target_iter,
- gint y,
- gint *line_top)
+ int y,
+ int *line_top)
{
GtkTextLine *line;
gboolean
gtk_text_layout_get_iter_at_pixel (GtkTextLayout *layout,
GtkTextIter *target_iter,
- gint x,
- gint y)
+ int x,
+ int y)
{
- gint trailing;
+ int trailing;
gboolean inside;
inside = gtk_text_layout_get_iter_at_position (layout, target_iter, &trailing, x, y);
gboolean
gtk_text_layout_get_iter_at_position (GtkTextLayout *layout,
GtkTextIter *target_iter,
- gint *trailing,
- gint x,
- gint y)
+ int *trailing,
+ int x,
+ int y)
{
GtkTextLine *line;
- gint byte_index;
- gint line_top;
+ int byte_index;
+ int line_top;
GtkTextLineDisplay *display;
gboolean inside;
{
GtkTextLine *line;
GtkTextLineDisplay *display;
- gint line_top;
- gint index;
+ int line_top;
+ int index;
GtkTextIter insert_iter;
PangoRectangle pango_strong_pos;
}
else
{
- gint index = display->insert_index;
+ int index = display->insert_index;
if (index < 0)
index = gtk_text_iter_get_line_index (&iter);
if (block && pos)
{
- gint line_top;
+ int line_top;
line_top = _gtk_text_btree_find_line_top (_gtk_text_buffer_get_btree (layout->buffer),
line, layout);
void
gtk_text_layout_get_line_yrange (GtkTextLayout *layout,
const GtkTextIter *iter,
- gint *y,
- gint *height)
+ int *y,
+ int *height)
{
GtkTextLine *line;
GtkTextLine *line;
GtkTextBTree *tree;
GtkTextLineDisplay *display;
- gint byte_index;
- gint x_offset;
+ int byte_index;
+ int x_offset;
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
g_return_if_fail (_gtk_text_iter_get_btree (iter) == _gtk_text_buffer_get_btree (layout->buffer));
static void
find_display_line_below (GtkTextLayout *layout,
GtkTextIter *iter,
- gint y)
+ int y)
{
GtkTextLine *line, *next;
GtkTextLine *found_line = NULL;
- gint line_top;
- gint found_byte = 0;
+ int line_top;
+ int found_byte = 0;
line = _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer),
layout, y, &line_top);
do
{
- gint first_y, last_y;
+ int first_y, last_y;
PangoLayoutLine *layout_line = pango_layout_iter_get_line_readonly (layout_iter);
found_byte = layout_line->start_index;
static void
find_display_line_above (GtkTextLayout *layout,
GtkTextIter *iter,
- gint y)
+ int y)
{
GtkTextLine *line;
GtkTextLine *found_line = NULL;
- gint line_top;
- gint found_byte = 0;
+ int line_top;
+ int found_byte = 0;
line = _gtk_text_btree_find_line_by_y (_gtk_text_buffer_get_btree (layout->buffer), layout, y, &line_top);
if (!line)
GtkTextLineDisplay *display = gtk_text_layout_get_line_display (layout, line, FALSE);
PangoRectangle logical_rect;
PangoLayoutIter *layout_iter;
- gint tmp_top;
+ int tmp_top;
layout_iter = pango_layout_get_iter (display->layout);
do
{
- gint first_y, last_y;
+ int first_y, last_y;
PangoLayoutLine *layout_line = pango_layout_iter_get_line_readonly (layout_iter);
found_byte = layout_line->start_index;
gboolean
gtk_text_layout_clamp_iter_to_vrange (GtkTextLayout *layout,
GtkTextIter *iter,
- gint top,
- gint bottom)
+ int top,
+ int bottom)
{
GdkRectangle iter_rect;
{
GtkTextLine *line;
GtkTextLineDisplay *display;
- gint line_byte;
+ int line_byte;
GSList *tmp_list;
PangoLayoutLine *layout_line;
GtkTextIter orig;
}
else
{
- gint prev_offset = layout_line->start_index;
+ int prev_offset = layout_line->start_index;
tmp_list = tmp_list->next;
while (tmp_list)
{
GtkTextLine *line;
GtkTextLineDisplay *display;
- gint line_byte;
+ int line_byte;
GtkTextIter orig;
gboolean found = FALSE;
gboolean found_after = FALSE;
gboolean
gtk_text_layout_move_iter_to_line_end (GtkTextLayout *layout,
GtkTextIter *iter,
- gint direction)
+ int direction)
{
GtkTextLine *line;
GtkTextLineDisplay *display;
- gint line_byte;
+ int line_byte;
GSList *tmp_list;
GtkTextIter orig;
{
GtkTextLine *line;
GtkTextLineDisplay *display;
- gint line_byte;
+ int line_byte;
GSList *tmp_list;
g_return_val_if_fail (GTK_IS_TEXT_LAYOUT (layout), FALSE);
gtk_text_layout_get_iter_at_line (GtkTextLayout *layout,
GtkTextIter *iter,
GtkTextLine *line,
- gint byte_offset)
+ int byte_offset)
{
_gtk_text_btree_get_iter_at_line (_gtk_text_buffer_get_btree (layout->buffer),
iter, line, byte_offset);
void
gtk_text_layout_move_iter_to_x (GtkTextLayout *layout,
GtkTextIter *iter,
- gint x)
+ int x)
{
GtkTextLine *line;
GtkTextLineDisplay *display;
- gint line_byte;
+ int line_byte;
PangoLayoutIter *layout_iter;
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
pango_layout_iter_at_last_line (layout_iter))
{
PangoRectangle logical_rect;
- gint byte_index, trailing;
- gint x_offset = display->x_offset * PANGO_SCALE;
+ int byte_index, trailing;
+ int x_offset = display->x_offset * PANGO_SCALE;
pango_layout_iter_get_line_extents (layout_iter, NULL, &logical_rect);
gboolean
gtk_text_layout_move_iter_visually (GtkTextLayout *layout,
GtkTextIter *iter,
- gint count)
+ int count)
{
GtkTextLineDisplay *display = NULL;
GtkTextIter orig;
while (count != 0)
{
GtkTextLine *line = _gtk_text_iter_get_text_line (iter);
- gint line_byte;
- gint extra_back = 0;
+ int line_byte;
+ int extra_back = 0;
gboolean strong;
int byte_count = _gtk_text_line_byte_count (line);
gtk_text_layout_before_buffer_insert_text (GtkTextBuffer *textbuffer,
GtkTextIter *iter,
gchar *str,
- gint len,
+ int len,
gpointer data)
{
GtkTextLayout *layout = GTK_TEXT_LAYOUT (data);
gtk_text_layout_after_buffer_insert_text (GtkTextBuffer *textbuffer,
GtkTextIter *iter,
gchar *str,
- gint len,
+ int len,
gpointer data)
{
GtkTextLayout *layout = GTK_TEXT_LAYOUT (data);
(selection_start_index == byte_offset + line->length && pango_layout_iter_at_last_line (iter))) &&
selection_end_index > byte_offset)
{
- gint *ranges = NULL;
- gint n_ranges, i;
+ int *ranges = NULL;
+ int n_ranges, i;
pango_layout_line_get_x_ranges (line, selection_start_index, selection_end_index, &ranges, &n_ranges);
GtkTextLayoutPrivate *priv;
GskPangoRenderer *crenderer;
GtkStyleContext *context;
- gint offset_y;
+ int offset_y;
GtkTextIter selection_start, selection_end;
gboolean have_selection;
GSList *line_list;
{
GtkTextLine *line = tmp_list->data;
GtkTextLineDisplay *line_display;
- gint selection_start_index = -1;
- gint selection_end_index = -1;
+ int selection_start_index = -1;
+ int selection_end_index = -1;
line_display = gtk_text_layout_get_line_display (layout, line, FALSE);
if (have_selection)
{
GtkTextIter line_start, line_end;
- gint byte_count;
+ int byte_count;
gtk_text_layout_get_iter_at_line (layout, &line_start, line, 0);
line_end = line_start;
gsk_pango_renderer_release (crenderer);
}
-gint
+int
gtk_text_line_display_compare (const GtkTextLineDisplay *display1,
const GtkTextLineDisplay *display2,
GtkTextLayout *layout)
{
- gint line1;
- gint line2;
+ int line1;
+ int line2;
line1 = _gtk_text_line_get_number (display1->line);
line2 = _gtk_text_line_get_number (display2->line);
/* width of the display area on-screen,
* i.e. pixels we should wrap to fit inside. */
- gint screen_width;
+ int screen_width;
/* width/height of the total logical area being layed out */
- gint width;
- gint height;
+ int width;
+ int height;
/* Pixel offsets from the left and from the top to be used when we
* draw; these allow us to create left/top margins. We don't need
* anything special for bottom/right margins, because those don't
* affect drawing.
*/
- /* gint left_edge; */
- /* gint top_edge; */
+ /* int left_edge; */
+ /* int top_edge; */
GtkTextBuffer *buffer;
- gint left_padding;
- gint right_padding;
+ int left_padding;
+ int right_padding;
/* Default style used if no tags override it */
GtkTextAttributes *default_style;
GtkTextAttributes *one_style_cache;
/* Whether we are allowed to wrap right now */
- gint wrap_loop_count;
+ int wrap_loop_count;
/* Whether to show the insertion cursor */
guint cursor_visible : 1;
gchar *preedit_string;
PangoAttrList *preedit_attrs;
- gint preedit_len;
- gint preedit_cursor;
+ int preedit_len;
+ int preedit_cursor;
guint overwrite_mode : 1;
};
GtkTextDirection direction;
- gint width; /* Width of layout */
- gint total_width; /* width - margins, if no width set on layout, if width set on layout, -1 */
- gint height;
+ int width; /* Width of layout */
+ int total_width; /* width - margins, if no width set on layout, if width set on layout, -1 */
+ int height;
/* Amount layout is shifted from left edge - this is the left margin
* plus any other factors, such as alignment or indentation.
*/
- gint x_offset;
- gint left_margin;
- gint right_margin;
- gint top_margin;
- gint bottom_margin;
- gint insert_index; /* Byte index of insert cursor within para or -1 */
+ int x_offset;
+ int left_margin;
+ int right_margin;
+ int top_margin;
+ int bottom_margin;
+ int insert_index; /* Byte index of insert cursor within para or -1 */
GtkTextLine *line;
void gtk_text_layout_default_style_changed (GtkTextLayout *layout);
void gtk_text_layout_set_screen_width (GtkTextLayout *layout,
- gint width);
+ int width);
void gtk_text_layout_set_preedit_string (GtkTextLayout *layout,
const gchar *preedit_string,
PangoAttrList *preedit_attrs,
- gint cursor_pos);
+ int cursor_pos);
void gtk_text_layout_set_cursor_visible (GtkTextLayout *layout,
gboolean cursor_visible);
gboolean gtk_text_layout_get_cursor_visible (GtkTextLayout *layout);
void gtk_text_layout_get_size (GtkTextLayout *layout,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
GSList* gtk_text_layout_get_lines (GtkTextLayout *layout,
- gint top_y,
- gint bottom_y,
- gint *first_line_y);
+ int top_y,
+ int bottom_y,
+ int *first_line_y);
void gtk_text_layout_wrap_loop_start (GtkTextLayout *layout);
void gtk_text_layout_wrap_loop_end (GtkTextLayout *layout);
GtkTextLineDisplay *gtk_text_line_display_ref (GtkTextLineDisplay *display);
void gtk_text_line_display_unref (GtkTextLineDisplay *display);
-gint gtk_text_line_display_compare (const GtkTextLineDisplay *display1,
+int gtk_text_line_display_compare (const GtkTextLineDisplay *display1,
const GtkTextLineDisplay *display2,
GtkTextLayout *layout);
void gtk_text_layout_get_line_at_y (GtkTextLayout *layout,
GtkTextIter *target_iter,
- gint y,
- gint *line_top);
+ int y,
+ int *line_top);
gboolean gtk_text_layout_get_iter_at_pixel (GtkTextLayout *layout,
GtkTextIter *iter,
- gint x,
- gint y);
+ int x,
+ int y);
gboolean gtk_text_layout_get_iter_at_position (GtkTextLayout *layout,
GtkTextIter *iter,
- gint *trailing,
- gint x,
- gint y);
+ int *trailing,
+ int x,
+ int y);
void gtk_text_layout_invalidate (GtkTextLayout *layout,
const GtkTextIter *start,
const GtkTextIter *end);
gboolean gtk_text_layout_is_valid (GtkTextLayout *layout);
void gtk_text_layout_validate_yrange (GtkTextLayout *layout,
GtkTextIter *anchor_line,
- gint y0_,
- gint y1_);
+ int y0_,
+ int y1_);
void gtk_text_layout_validate (GtkTextLayout *layout,
- gint max_pixels);
+ int max_pixels);
GtkTextLineData* gtk_text_layout_wrap (GtkTextLayout *layout,
GtkTextLine *line,
GtkTextLineData *line_data);
void gtk_text_layout_changed (GtkTextLayout *layout,
- gint y,
- gint old_height,
- gint new_height);
+ int y,
+ int old_height,
+ int new_height);
void gtk_text_layout_cursors_changed (GtkTextLayout *layout,
- gint y,
- gint old_height,
- gint new_height);
+ int y,
+ int old_height,
+ int new_height);
void gtk_text_layout_get_iter_location (GtkTextLayout *layout,
const GtkTextIter *iter,
GdkRectangle *rect);
void gtk_text_layout_get_line_yrange (GtkTextLayout *layout,
const GtkTextIter *iter,
- gint *y,
- gint *height);
+ int *y,
+ int *height);
void gtk_text_layout_get_cursor_locations (GtkTextLayout *layout,
GtkTextIter *iter,
GdkRectangle *strong_pos,
GdkRectangle *pos);
gboolean gtk_text_layout_clamp_iter_to_vrange (GtkTextLayout *layout,
GtkTextIter *iter,
- gint top,
- gint bottom);
+ int top,
+ int bottom);
gboolean gtk_text_layout_move_iter_to_line_end (GtkTextLayout *layout,
GtkTextIter *iter,
- gint direction);
+ int direction);
gboolean gtk_text_layout_move_iter_to_previous_line (GtkTextLayout *layout,
GtkTextIter *iter);
gboolean gtk_text_layout_move_iter_to_next_line (GtkTextLayout *layout,
GtkTextIter *iter);
void gtk_text_layout_move_iter_to_x (GtkTextLayout *layout,
GtkTextIter *iter,
- gint x);
+ int x);
gboolean gtk_text_layout_move_iter_visually (GtkTextLayout *layout,
GtkTextIter *iter,
- gint count);
+ int count);
gboolean gtk_text_layout_iter_starts_line (GtkTextLayout *layout,
const GtkTextIter *iter);
void gtk_text_layout_get_iter_at_line (GtkTextLayout *layout,
GtkTextIter *iter,
GtkTextLine *line,
- gint byte_offset);
+ int byte_offset);
void gtk_text_child_anchor_register_child (GtkTextChildAnchor *anchor,
GtkWidget *child,
#if DEBUG_LINE_DISPLAY_CACHE
guint log_source;
- gint hits;
- gint misses;
- gint inval;
- gint inval_cursors;
- gint inval_by_line;
- gint inval_by_range;
- gint inval_by_y_range;
+ int hits;
+ int misses;
+ int inval;
+ int inval_cursors;
+ int inval_by_line;
+ int inval_by_range;
+ int inval_by_y_range;
#endif
};
GtkTextLayout *layout)
{
GSequenceIter *iter;
- gint last = G_MAXUINT;
+ int last = G_MAXUINT;
g_assert (cache != NULL);
g_assert (cache->sorted_by_line != NULL);
static GSequenceIter *
find_iter_at_at_y (GtkTextLineDisplayCache *cache,
GtkTextLayout *layout,
- gint y)
+ int y)
{
GtkTextBTree *btree;
GSequenceIter *left;
for (;;)
{
GtkTextLineDisplay *display;
- gint cache_y;
- gint cache_height;
+ int cache_y;
+ int cache_height;
if (left == right)
mid = left;
void
gtk_text_line_display_cache_invalidate_y_range (GtkTextLineDisplayCache *cache,
GtkTextLayout *layout,
- gint y,
- gint old_height,
+ int y,
+ int old_height,
gboolean cursors_only)
{
GSequenceIter *iter;
while (!g_sequence_iter_is_end (iter))
{
GtkTextLineDisplay *display;
- gint cache_y;
- gint cache_height;
+ int cache_y;
+ int cache_height;
display = g_sequence_get (iter);
iter = g_sequence_iter_next (iter);
gboolean cursors_only);
void gtk_text_line_display_cache_invalidate_y_range (GtkTextLineDisplayCache *cache,
GtkTextLayout *layout,
- gint y,
- gint height,
+ int y,
+ int height,
gboolean cursors_only);
void gtk_text_line_display_cache_set_mru_size (GtkTextLineDisplayCache *cache,
guint mru_size);
void (* activate) (GtkText *self);
void (* move_cursor) (GtkText *self,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend);
void (* insert_at_cursor) (GtkText *self,
const gchar *str);
void (* delete_from_cursor) (GtkText *self,
GtkDeleteType type,
- gint count);
+ int count);
void (* backspace) (GtkText *self);
void (* cut_clipboard) (GtkText *self);
void (* copy_clipboard) (GtkText *self);
struct _GtkTextTagInfo {
GtkTextTag *tag;
GtkTextBTreeNode *tag_root; /* highest-level node containing the tag */
- gint toggle_count; /* total toggles of this tag below tag_root */
+ int toggle_count; /* total toggles of this tag below tag_root */
};
/* Body of a segment that toggles a tag on or off */
/* Split seg at index, returning list of two new segments, and freeing seg */
typedef GtkTextLineSegment* (*GtkTextSegSplitFunc) (GtkTextLineSegment *seg,
- gint index);
+ int index);
/* Delete seg which is contained in line; if tree_gone, the tree is being
* freed in its entirety, which may matter for some reason (?)
pango_font_description_set_stretch (desc, pango_font_description_get_stretch (desc));
if (to_set & PANGO_FONT_MASK_SIZE)
{
- gint size = pango_font_description_get_size (desc);
+ int size = pango_font_description_get_size (desc);
if (size <= 0)
{
size = 10 * PANGO_SCALE;
*/
typedef struct {
- gint high;
- gint low;
- gint delta;
+ int high;
+ int low;
+ int delta;
} DeltaData;
static void
*
* Returns: The tag’s priority.
**/
-gint
+int
gtk_text_tag_get_priority (GtkTextTag *tag)
{
g_return_val_if_fail (GTK_IS_TEXT_TAG (tag), 0);
**/
void
gtk_text_tag_set_priority (GtkTextTag *tag,
- gint priority)
+ int priority)
{
GtkTextTagPrivate *priv;
DeltaData dd;
GDK_AVAILABLE_IN_ALL
GtkTextTag *gtk_text_tag_new (const gchar *name);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_tag_get_priority (GtkTextTag *tag);
+int gtk_text_tag_get_priority (GtkTextTag *tag);
GDK_AVAILABLE_IN_ALL
void gtk_text_tag_set_priority (GtkTextTag *tag,
- gint priority);
+ int priority);
GDK_AVAILABLE_IN_ALL
void gtk_text_tag_changed (GtkTextTag *tag,
gboolean size_changed);
GSList *anonymous;
GSList *buffers;
- gint anon_count;
+ int anon_count;
guint seen_invisible : 1;
};
*
* Returns: number of tags in @table
**/
-gint
+int
gtk_text_tag_table_get_size (GtkTextTagTable *table)
{
GtkTextTagTablePrivate *priv;
GtkTextTagTableForeach func,
gpointer data);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_tag_table_get_size (GtkTextTagTable *table);
+int gtk_text_tag_table_get_size (GtkTextTagTable *table);
G_END_DECLS
#define ELLIPSIS_CHARACTER "\xe2\x80\xa6"
static void
-append_n_lines (GString *str, const gchar *text, GSList *lines, gint n_lines)
+append_n_lines (GString *str, const gchar *text, GSList *lines, int n_lines)
{
PangoLayoutLine *line;
- gint i;
+ int i;
for (i = 0; i < n_lines; i++)
{
const gchar *text;
GString *str;
GSList *lines, *elem;
- gint n_lines;
+ int n_lines;
n_lines = pango_layout_get_line_count (layout);
PangoContext *context;
PangoLayout *layout;
GdkPaintable *paintable;
- gint layout_width;
+ int layout_width;
const GdkRGBA *color;
g_return_val_if_fail (widget != NULL, NULL);
values->font = gtk_css_style_get_pango_font (style);
}
-static gint
+static int
get_border_window_size (GtkTextView *text_view,
GtkTextWindowType window_type)
{
GtkAllocation allocation;
GdkPaintable *paintable;
GtkSnapshot *snapshot;
- gint layout_width, layout_height;
+ int layout_width, layout_height;
GtkTextBuffer *new_buffer;
GtkTextLayout *layout;
GtkTextAttributes *style;
return paintable;
}
-static gint
+static int
layout_get_char_width (PangoLayout *layout)
{
- gint width;
+ int width;
PangoFontMetrics *metrics;
const PangoFontDescription *font_desc;
PangoContext *context = pango_layout_get_context (layout);
*/
gboolean
_gtk_text_util_get_block_cursor_location (PangoLayout *layout,
- gint index,
+ int index,
PangoRectangle *pos,
gboolean *at_line_end)
{
PangoRectangle strong_pos, weak_pos;
PangoLayoutLine *layout_line;
gboolean rtl;
- gint line_no;
+ int line_no;
const gchar *text;
g_return_val_if_fail (layout != NULL, FALSE);
{
PangoLayoutIter *iter;
PangoRectangle line_rect;
- gint i;
- gint left, right;
+ int i;
+ int left, right;
const gchar *p;
p = g_utf8_prev_char (text + index);
GtkTextIter *end);
gboolean _gtk_text_util_get_block_cursor_location (PangoLayout *layout,
- gint index_,
+ int index_,
PangoRectangle *rectangle,
gboolean *at_line_end);
guint im_spot_idle;
gchar *im_module;
- gint dnd_x;
- gint dnd_y;
+ int dnd_x;
+ int dnd_y;
GtkTextHandle *text_handles[TEXT_HANDLE_N_HANDLES];
GtkWidget *selection_bubble;
/* X offset between widget coordinates and buffer coordinates
* taking left_padding in account
*/
- gint xoffset;
+ int xoffset;
/* Y offset between widget coordinates and buffer coordinates
* taking top_padding and top_margin in account
*/
- gint yoffset;
+ int yoffset;
/* Width and height of the buffer */
- gint width;
- gint height;
+ int width;
+ int height;
/* The virtual cursor position is normally the same as the
* actual (strong) cursor position, except in two circumstances:
* In case a), virtual_cursor_x is preserved, but not virtual_cursor_y
* In case b), both virtual_cursor_x and virtual_cursor_y are preserved.
*/
- gint virtual_cursor_x; /* -1 means use actual cursor position */
- gint virtual_cursor_y; /* -1 means use actual cursor position */
+ int virtual_cursor_x; /* -1 means use actual cursor position */
+ int virtual_cursor_y; /* -1 means use actual cursor position */
GtkTextMark *first_para_mark; /* Mark at the beginning of the first onscreen paragraph */
- gint first_para_pixels; /* Offset of top of screen in the first onscreen paragraph */
+ int first_para_pixels; /* Offset of top of screen in the first onscreen paragraph */
guint64 blink_start_time;
guint blink_tick;
GdkDrag *drag;
/* Default style settings */
- gint pixels_above_lines;
- gint pixels_below_lines;
- gint pixels_inside_wrap;
+ int pixels_above_lines;
+ int pixels_below_lines;
+ int pixels_inside_wrap;
GtkWrapMode wrap_mode;
GtkJustification justify;
- gint left_margin;
- gint right_margin;
- gint top_margin;
- gint bottom_margin;
- gint left_padding;
- gint right_padding;
- gint top_padding;
- gint bottom_padding;
+ int left_margin;
+ int right_margin;
+ int top_margin;
+ int bottom_margin;
+ int left_padding;
+ int right_padding;
+ int top_padding;
+ int bottom_padding;
- gint indent;
+ int indent;
gint64 handle_place_time;
PangoTabArray *tabs;
guint editable : 1;
GtkStateFlags previous_state);
static void gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTextView *text_view);
GVariant *parameters);
static void gtk_text_view_move_cursor (GtkTextView *text_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend_selection);
static void gtk_text_view_move_viewport (GtkTextView *text_view,
GtkScrollStep step,
- gint count);
+ int count);
static void gtk_text_view_set_anchor (GtkTextView *text_view);
static gboolean gtk_text_view_scroll_pages (GtkTextView *text_view,
- gint count,
+ int count,
gboolean extend_selection);
static gboolean gtk_text_view_scroll_hpages(GtkTextView *text_view,
- gint count,
+ int count,
gboolean extend_selection);
static void gtk_text_view_insert_at_cursor (GtkTextView *text_view,
const gchar *str);
static void gtk_text_view_delete_from_cursor (GtkTextView *text_view,
GtkDeleteType type,
- gint count);
+ int count);
static void gtk_text_view_backspace (GtkTextView *text_view);
static void gtk_text_view_cut_clipboard (GtkTextView *text_view);
static void gtk_text_view_copy_clipboard (GtkTextView *text_view);
static void gtk_text_view_start_selection_dnd (GtkTextView *text_view,
const GtkTextIter *iter,
GdkEvent *event,
- gint x,
- gint y);
+ int x,
+ int y);
static void gtk_text_view_check_cursor_blink (GtkTextView *text_view);
static void gtk_text_view_pend_cursor_blink (GtkTextView *text_view);
static void gtk_text_view_stop_cursor_blink (GtkTextView *text_view);
static gboolean gtk_text_view_retrieve_surrounding_handler (GtkIMContext *context,
GtkTextView *text_view);
static gboolean gtk_text_view_delete_surrounding_handler (GtkIMContext *context,
- gint offset,
- gint n_chars,
+ int offset,
+ int n_chars,
GtkTextView *text_view);
static void gtk_text_view_mark_set_handler (GtkTextBuffer *buffer,
GtkTextView *view);
static void gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
GtkTextIter *cursor,
- gint *x,
- gint *y);
+ int *x,
+ int *y);
static void gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,
- gint x,
- gint y);
+ int x,
+ int y);
static void gtk_text_view_do_popup (GtkTextView *text_view,
GdkEvent *event);
static void gtk_text_view_handle_drag_started (GtkTextHandle *handle,
GtkTextView *text_view);
static void gtk_text_view_handle_dragged (GtkTextHandle *handle,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTextView *text_view);
static void gtk_text_view_handle_drag_finished (GtkTextHandle *handle,
GtkTextView *text_view);
static void text_window_free (GtkTextWindow *win);
static void text_window_size_allocate (GtkTextWindow *win,
GdkRectangle *rect);
-static gint text_window_get_width (GtkTextWindow *win);
-static gint text_window_get_height (GtkTextWindow *win);
+static int text_window_get_width (GtkTextWindow *win);
+static int text_window_get_height (GtkTextWindow *win);
static guint signals[LAST_SIGNAL] = { 0 };
guint keyval,
guint modmask,
GtkMovementStep step,
- gint count)
+ int count)
{
g_assert ((modmask & GDK_SHIFT_MASK) == 0);
gboolean
gtk_text_view_get_iter_at_location (GtkTextView *text_view,
GtkTextIter *iter,
- gint x,
- gint y)
+ int x,
+ int y)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
gboolean
gtk_text_view_get_iter_at_position (GtkTextView *text_view,
GtkTextIter *iter,
- gint *trailing,
- gint x,
- gint y)
+ int *trailing,
+ int x,
+ int y)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
void
gtk_text_view_get_line_yrange (GtkTextView *text_view,
const GtkTextIter *iter,
- gint *y,
- gint *height)
+ int *y,
+ int *height)
{
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view));
void
gtk_text_view_get_line_at_y (GtkTextView *text_view,
GtkTextIter *target_iter,
- gint y,
- gint *line_top)
+ int y,
+ int *line_top)
{
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
GtkWidget *widget;
GdkRectangle cursor;
- gint cursor_bottom;
- gint cursor_right;
+ int cursor_bottom;
+ int cursor_right;
GdkRectangle screen;
GdkRectangle screen_dest;
- gint screen_inner_left;
- gint screen_inner_right;
- gint screen_inner_top;
- gint screen_inner_bottom;
+ int screen_inner_left;
+ int screen_inner_right;
+ int screen_inner_top;
+ int screen_inner_bottom;
- gint border_xoffset = 0;
- gint border_yoffset = 0;
- gint within_margin_xoffset;
- gint within_margin_yoffset;
+ int border_xoffset = 0;
+ int border_yoffset = 0;
+ int within_margin_xoffset;
+ int within_margin_yoffset;
- gint buffer_bottom;
- gint buffer_right;
+ int buffer_bottom;
+ int buffer_right;
gboolean retval = FALSE;
/* Vertical scroll */
if (use_align)
{
- gint cursor_y_alignment_offset;
+ int cursor_y_alignment_offset;
cursor_y_alignment_offset = (cursor.height * yalign) - (screen_dest.height * yalign);
screen_dest.y = cursor.y + cursor_y_alignment_offset - within_margin_yoffset;
if (use_align)
{
- gint cursor_x_alignment_offset;
+ int cursor_x_alignment_offset;
cursor_x_alignment_offset = (cursor.width * xalign) - (screen_dest.width * xalign);
screen_dest.x = cursor.x + cursor_x_alignment_offset - within_margin_xoffset;
gtk_text_view_update_adjustments (GtkTextView *text_view)
{
GtkTextViewPrivate *priv;
- gint width = 0, height = 0;
+ int width = 0, height = 0;
DV(g_print(">Updating adjustments ("G_STRLOC")\n"));
**/
void
gtk_text_view_set_pixels_above_lines (GtkTextView *text_view,
- gint pixels_above_lines)
+ int pixels_above_lines)
{
GtkTextViewPrivate *priv;
*
* Returns: default number of pixels above paragraphs
**/
-gint
+int
gtk_text_view_get_pixels_above_lines (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
**/
void
gtk_text_view_set_pixels_below_lines (GtkTextView *text_view,
- gint pixels_below_lines)
+ int pixels_below_lines)
{
GtkTextViewPrivate *priv;
*
* Returns: default number of blank pixels below paragraphs
**/
-gint
+int
gtk_text_view_get_pixels_below_lines (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
**/
void
gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view,
- gint pixels_inside_wrap)
+ int pixels_inside_wrap)
{
GtkTextViewPrivate *priv;
*
* Returns: default number of pixels of blank space between wrapped lines
**/
-gint
+int
gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
*/
void
gtk_text_view_set_left_margin (GtkTextView *text_view,
- gint left_margin)
+ int left_margin)
{
GtkTextViewPrivate *priv = text_view->priv;
*
* Returns: left margin in pixels
*/
-gint
+int
gtk_text_view_get_left_margin (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
*/
void
gtk_text_view_set_right_margin (GtkTextView *text_view,
- gint right_margin)
+ int right_margin)
{
GtkTextViewPrivate *priv = text_view->priv;
*
* Returns: right margin in pixels
*/
-gint
+int
gtk_text_view_get_right_margin (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
*/
void
gtk_text_view_set_top_margin (GtkTextView *text_view,
- gint top_margin)
+ int top_margin)
{
GtkTextViewPrivate *priv = text_view->priv;
*
* Returns: top margin in pixels
**/
-gint
+int
gtk_text_view_get_top_margin (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
*/
void
gtk_text_view_set_bottom_margin (GtkTextView *text_view,
- gint bottom_margin)
+ int bottom_margin)
{
GtkTextViewPrivate *priv = text_view->priv;
*
* Returns: bottom margin in pixels
*/
-gint
+int
gtk_text_view_get_bottom_margin (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
**/
void
gtk_text_view_set_indent (GtkTextView *text_view,
- gint indent)
+ int indent)
{
GtkTextViewPrivate *priv;
*
* Returns: number of pixels of indentation
**/
-gint
+int
gtk_text_view_get_indent (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
const AnchoredChild *vc,
GtkAllocation *allocation)
{
- gint buffer_y;
+ int buffer_y;
GtkTextIter iter;
GtkRequisition req;
static void
gtk_anchored_child_allocated (GtkTextLayout *layout,
GtkWidget *child,
- gint x,
- gint y,
+ int x,
+ int y,
gpointer data)
{
AnchoredChild *vc = NULL;
{
GtkTextView *text_view;
GtkTextViewPrivate *priv;
- gint width, height;
+ int width, height;
GdkRectangle text_rect;
GdkRectangle left_rect;
GdkRectangle right_rect;
static void
changed_handler (GtkTextLayout *layout,
- gint start_y,
- gint old_height,
- gint new_height,
+ int start_y,
+ int old_height,
+ int new_height,
gpointer data)
{
GtkTextView *text_view;
static void
_text_window_to_widget_coords (GtkTextView *text_view,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
GtkTextViewPrivate *priv = text_view->priv;
static void
_widget_to_text_surface_coords (GtkTextView *text_view,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
GtkTextViewPrivate *priv = text_view->priv;
{
GtkTextViewPrivate *priv;
GdkRectangle rect;
- gint x, y;
+ int x, y;
priv = text_view->priv;
gtk_text_view_get_cursor_locations (text_view, iter, &rect, NULL);
static void
gtk_text_view_show_magnifier (GtkTextView *text_view,
GtkTextIter *iter,
- gint x,
- gint y)
+ int x,
+ int y)
{
cairo_rectangle_int_t rect;
GtkTextViewPrivate *priv;
static void
gtk_text_view_handle_dragged (GtkTextHandle *handle,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTextView *text_view)
{
GtkTextViewPrivate *priv;
get_iter_from_gesture (GtkTextView *text_view,
GtkGesture *gesture,
GtkTextIter *iter,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
GdkEventSequence *sequence;
GtkTextViewPrivate *priv;
- gint xcoord, ycoord;
+ int xcoord, ycoord;
gdouble px, py;
priv = text_view->priv;
static void
gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTextView *text_view)
return paste;
}
-static gint
+static int
get_cursor_time (GtkTextView *text_view)
{
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
- gint time;
+ int time;
g_object_get (settings, "gtk-cursor-blink-time", &time, NULL);
return time;
}
-static gint
+static int
get_cursor_blink_timeout (GtkTextView *text_view)
{
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
- gint time;
+ int time;
g_object_get (settings, "gtk-cursor-blink-timeout", &time, NULL);
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
GtkTextViewPrivate *priv = text_view->priv;
BlinkData *data = user_data;
- gint blink_timeout;
- gint blink_time;
+ int blink_timeout;
+ int blink_time;
guint64 now;
float phase;
float alpha;
static gboolean
gtk_text_view_move_iter_by_lines (GtkTextView *text_view,
GtkTextIter *newplace,
- gint count)
+ int count)
{
gboolean ret = TRUE;
static void
gtk_text_view_move_cursor (GtkTextView *text_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend_selection)
{
GtkTextViewPrivate *priv;
GtkTextIter insert;
GtkTextIter newplace;
gboolean cancel_selection = FALSE;
- gint cursor_x_pos = 0;
+ int cursor_x_pos = 0;
GtkDirectionType leave_direction = -1;
priv = text_view->priv;
static void
gtk_text_view_move_viewport (GtkTextView *text_view,
GtkScrollStep step,
- gint count)
+ int count)
{
GtkAdjustment *adjustment;
gdouble increment;
static gboolean
gtk_text_view_scroll_pages (GtkTextView *text_view,
- gint count,
+ int count,
gboolean extend_selection)
{
GtkTextViewPrivate *priv;
GtkAdjustment *adjustment;
- gint cursor_x_pos, cursor_y_pos;
+ int cursor_x_pos, cursor_y_pos;
GtkTextMark *insert_mark;
GtkTextIter old_insert;
GtkTextIter new_insert;
GtkTextIter anchor;
gdouble newval;
gdouble oldval;
- gint y0, y1;
+ int y0, y1;
priv = text_view->priv;
static gboolean
gtk_text_view_scroll_hpages (GtkTextView *text_view,
- gint count,
+ int count,
gboolean extend_selection)
{
GtkTextViewPrivate *priv;
GtkAdjustment *adjustment;
- gint cursor_x_pos, cursor_y_pos;
+ int cursor_x_pos, cursor_y_pos;
GtkTextMark *insert_mark;
GtkTextIter old_insert;
GtkTextIter new_insert;
gdouble newval;
gdouble oldval;
- gint y, height;
+ int y, height;
priv = text_view->priv;
static void
gtk_text_view_delete_from_cursor (GtkTextView *text_view,
GtkDeleteType type,
- gint count)
+ int count)
{
GtkTextViewPrivate *priv;
GtkTextIter insert;
static gboolean
drag_gesture_get_text_surface_coords (GtkGestureDrag *gesture,
GtkTextView *text_view,
- gint *start_x,
- gint *start_y,
- gint *x,
- gint *y)
+ int *start_x,
+ int *start_y,
+ int *x,
+ int *y)
{
gdouble sx, sy, ox, oy;
gdouble offset_y,
GtkTextView *text_view)
{
- gint start_x, start_y, x, y;
+ int start_x, start_y, x, y;
GdkEventSequence *sequence;
gboolean is_touchscreen;
GdkEvent *event;
if (!is_touchscreen)
{
GtkTextIter iter;
- gint buffer_x, buffer_y;
+ int buffer_x, buffer_y;
gtk_text_view_window_to_buffer_coords (text_view,
GTK_TEXT_WINDOW_TEXT,
GtkTextView *text_view)
{
gboolean is_touchscreen, clicked_in_selection;
- gint start_x, start_y, x, y;
+ int start_x, start_y, x, y;
GdkEventSequence *sequence;
GtkTextViewPrivate *priv;
GdkEvent *event;
gtk_text_view_start_selection_dnd (GtkTextView *text_view,
const GtkTextIter *iter,
GdkEvent *event,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkWidget *widget = GTK_WIDGET (text_view);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
GtkTextIter newplace;
GtkTextIter start;
GtkTextIter end;
- gint bx, by;
+ int bx, by;
gboolean can_accept = FALSE;
gtk_text_view_window_to_buffer_coords (text_view,
gtk_text_view_set_hadjustment_values (GtkTextView *text_view)
{
GtkTextViewPrivate *priv;
- gint screen_width;
+ int screen_width;
gdouble old_value;
gdouble new_value;
gdouble new_upper;
{
GtkTextViewPrivate *priv;
GtkTextIter first_para;
- gint screen_height;
- gint y;
+ int screen_height;
+ int y;
gdouble old_value;
gdouble new_value;
gdouble new_upper;
{
GtkTextViewPrivate *priv;
GtkTextIter iter;
- gint line_top;
- gint dx = 0;
- gint dy = 0;
+ int line_top;
+ int dx = 0;
+ int dy = 0;
priv = text_view->priv;
if (adjustment == priv->hadjustment)
{
- dx = priv->xoffset - (gint)gtk_adjustment_get_value (adjustment);
- priv->xoffset = (gint)gtk_adjustment_get_value (adjustment) - priv->left_padding;
+ dx = priv->xoffset - (int)gtk_adjustment_get_value (adjustment);
+ priv->xoffset = (int)gtk_adjustment_get_value (adjustment) - priv->left_padding;
}
else if (adjustment == priv->vadjustment)
{
- dy = priv->yoffset - (gint)gtk_adjustment_get_value (adjustment) + priv->top_margin ;
+ dy = priv->yoffset - (int)gtk_adjustment_get_value (adjustment) + priv->top_margin ;
priv->yoffset -= dy;
if (priv->layout)
GtkTextViewPrivate *priv;
gchar *str;
PangoAttrList *attrs;
- gint cursor_pos;
+ int cursor_pos;
GtkTextIter iter;
priv = text_view->priv;
{
GtkTextIter start;
GtkTextIter end;
- gint pos;
+ int pos;
gchar *text;
gtk_text_buffer_get_iter_at_mark (text_view->priv->buffer, &start,
static gboolean
gtk_text_view_delete_surrounding_handler (GtkIMContext *context,
- gint offset,
- gint n_chars,
+ int offset,
+ int n_chars,
GtkTextView *text_view)
{
GtkTextViewPrivate *priv;
static void
gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
GtkTextIter *cursor,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
GtkTextViewPrivate *priv;
GtkTextIter insert;
static void
gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,
- gint x,
- gint y)
+ int x,
+ int y)
{
GdkRectangle pos;
cairo_rectangle_int_t rect_cursor, rect_bound;
GtkTextIter cursor, bound;
GtkTextBuffer *buffer;
- gint x1, y1, x2, y2;
+ int x1, y1, x2, y2;
buffer = get_buffer (text_view);
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
win->allocation = *rect;
}
-static gint
+static int
text_window_get_width (GtkTextWindow *win)
{
return win->allocation.width;
}
-static gint
+static int
text_window_get_height (GtkTextWindow *win)
{
return win->allocation.height;
void
gtk_text_view_buffer_to_window_coords (GtkTextView *text_view,
GtkTextWindowType win,
- gint buffer_x,
- gint buffer_y,
- gint *window_x,
- gint *window_y)
+ int buffer_x,
+ int buffer_y,
+ int *window_x,
+ int *window_y)
{
GtkTextViewPrivate *priv = text_view->priv;
void
gtk_text_view_window_to_buffer_coords (GtkTextView *text_view,
GtkTextWindowType win,
- gint window_x,
- gint window_y,
- gint *buffer_x,
- gint *buffer_y)
+ int window_x,
+ int window_y,
+ int *buffer_x,
+ int *buffer_y)
{
GtkTextViewPrivate *priv = text_view->priv;
void
gtk_text_view_add_overlay (GtkTextView *text_view,
GtkWidget *child,
- gint xpos,
- gint ypos)
+ int xpos,
+ int ypos)
{
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (GTK_IS_WIDGET (child));
void
gtk_text_view_move_overlay (GtkTextView *text_view,
GtkWidget *child,
- gint xpos,
- gint ypos)
+ int xpos,
+ int ypos)
{
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (GTK_IS_WIDGET (child));
gboolean
gtk_text_view_move_visually (GtkTextView *text_view,
GtkTextIter *iter,
- gint count)
+ int count)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
void (* move_cursor) (GtkTextView *text_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend_selection);
void (* set_anchor) (GtkTextView *text_view);
void (* insert_at_cursor) (GtkTextView *text_view,
const gchar *str);
void (* delete_from_cursor) (GtkTextView *text_view,
GtkDeleteType type,
- gint count);
+ int count);
void (* backspace) (GtkTextView *text_view);
void (* cut_clipboard) (GtkTextView *text_view);
void (* copy_clipboard) (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_view_get_iter_at_location (GtkTextView *text_view,
GtkTextIter *iter,
- gint x,
- gint y);
+ int x,
+ int y);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_view_get_iter_at_position (GtkTextView *text_view,
GtkTextIter *iter,
- gint *trailing,
- gint x,
- gint y);
+ int *trailing,
+ int x,
+ int y);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_get_line_yrange (GtkTextView *text_view,
const GtkTextIter *iter,
- gint *y,
- gint *height);
+ int *y,
+ int *height);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_get_line_at_y (GtkTextView *text_view,
GtkTextIter *target_iter,
- gint y,
- gint *line_top);
+ int y,
+ int *line_top);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_buffer_to_window_coords (GtkTextView *text_view,
GtkTextWindowType win,
- gint buffer_x,
- gint buffer_y,
- gint *window_x,
- gint *window_y);
+ int buffer_x,
+ int buffer_y,
+ int *window_x,
+ int *window_y);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_window_to_buffer_coords (GtkTextView *text_view,
GtkTextWindowType win,
- gint window_x,
- gint window_y,
- gint *buffer_x,
- gint *buffer_y);
+ int window_x,
+ int window_y,
+ int *buffer_x,
+ int *buffer_y);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_view_forward_display_line (GtkTextView *text_view,
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_view_move_visually (GtkTextView *text_view,
GtkTextIter *iter,
- gint count);
+ int count);
GDK_AVAILABLE_IN_ALL
gboolean gtk_text_view_im_context_filter_keypress (GtkTextView *text_view,
GDK_AVAILABLE_IN_ALL
void gtk_text_view_add_overlay (GtkTextView *text_view,
GtkWidget *child,
- gint xpos,
- gint ypos);
+ int xpos,
+ int ypos);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_move_overlay (GtkTextView *text_view,
GtkWidget *child,
- gint xpos,
- gint ypos);
+ int xpos,
+ int ypos);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_remove (GtkTextView *text_view,
gboolean gtk_text_view_get_accepts_tab (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_pixels_above_lines (GtkTextView *text_view,
- gint pixels_above_lines);
+ int pixels_above_lines);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_pixels_above_lines (GtkTextView *text_view);
+int gtk_text_view_get_pixels_above_lines (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_pixels_below_lines (GtkTextView *text_view,
- gint pixels_below_lines);
+ int pixels_below_lines);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_pixels_below_lines (GtkTextView *text_view);
+int gtk_text_view_get_pixels_below_lines (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view,
- gint pixels_inside_wrap);
+ int pixels_inside_wrap);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view);
+int gtk_text_view_get_pixels_inside_wrap (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_justification (GtkTextView *text_view,
GtkJustification justification);
GtkJustification gtk_text_view_get_justification (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_left_margin (GtkTextView *text_view,
- gint left_margin);
+ int left_margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_left_margin (GtkTextView *text_view);
+int gtk_text_view_get_left_margin (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_right_margin (GtkTextView *text_view,
- gint right_margin);
+ int right_margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_right_margin (GtkTextView *text_view);
+int gtk_text_view_get_right_margin (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_top_margin (GtkTextView *text_view,
- gint top_margin);
+ int top_margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_top_margin (GtkTextView *text_view);
+int gtk_text_view_get_top_margin (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_bottom_margin (GtkTextView *text_view,
- gint bottom_margin);
+ int bottom_margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_bottom_margin (GtkTextView *text_view);
+int gtk_text_view_get_bottom_margin (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_indent (GtkTextView *text_view,
- gint indent);
+ int indent);
GDK_AVAILABLE_IN_ALL
-gint gtk_text_view_get_indent (GtkTextView *text_view);
+int gtk_text_view_get_indent (GtkTextView *text_view);
GDK_AVAILABLE_IN_ALL
void gtk_text_view_set_tabs (GtkTextView *text_view,
PangoTabArray *tabs);
GtkWidget *
_gtk_widget_find_at_coords (GdkSurface *surface,
- gint surface_x,
- gint surface_y,
- gint *widget_x,
- gint *widget_y)
+ int surface_x,
+ int surface_y,
+ int *widget_x,
+ int *widget_y)
{
GtkWidget *event_widget;
GtkWidget *picked_widget;
return picked_widget;
}
-static gint
+static int
tooltip_browse_mode_expired (gpointer data)
{
GtkTooltip *tooltip;
static gboolean
gtk_tooltip_run_requery (GtkWidget **widget,
GtkTooltip *tooltip,
- gint *x,
- gint *y)
+ int *x,
+ int *y)
{
gboolean has_tooltip = FALSE;
gboolean return_value = FALSE;
gtk_tooltip_show_tooltip (GdkDisplay *display)
{
double px, py;
- gint x, y;
+ int x, y;
GdkSurface *surface;
GtkWidget *tooltip_widget;
GdkSeat *seat;
gtk_widget_hide (tooltip->window);
}
-static gint
+static int
tooltip_popup_timeout (gpointer data)
{
GdkDisplay *display;
void gtk_tooltip_trigger_tooltip_query (GtkWidget *widget);
GtkWidget * _gtk_widget_find_at_coords (GdkSurface *surface,
- gint surface_x,
- gint surface_y,
- gint *widget_x,
- gint *widget_y);
+ int surface_x,
+ int surface_y,
+ int *widget_x,
+ int *widget_y);
void gtk_tooltip_maybe_allocate (GtkNative *native);
void gtk_tooltip_unset_surface (GtkNative *native);
gulong file_monitor_changed_id;
gboolean pending;
- gint timeout_id;
+ int timeout_id;
guint has_trash : 1;
};
GType *column_headers)
{
GtkTreeDataList *tmp, *next;
- gint i = 0;
+ int i = 0;
tmp = list;
gboolean
_gtk_tree_data_list_check_type (GType type)
{
- gint i = 0;
+ int i = 0;
static const GType type_list[] =
{
G_TYPE_BOOLEAN,
g_value_set_uchar (value, (guchar) list->data.v_uchar);
break;
case G_TYPE_INT:
- g_value_set_int (value, (gint) list->data.v_int);
+ g_value_set_int (value, (int) list->data.v_int);
break;
case G_TYPE_UINT:
g_value_set_uint (value, (guint) list->data.v_uint);
return new_list;
}
-gint
+int
_gtk_tree_data_list_compare_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
- gint column = GPOINTER_TO_INT (user_data);
+ int column = GPOINTER_TO_INT (user_data);
GType type = gtk_tree_model_get_column_type (model, column);
GValue a_value = G_VALUE_INIT;
GValue b_value = G_VALUE_INIT;
- gint retval;
+ int retval;
const gchar *stra, *strb;
gtk_tree_model_get_value (model, a, column, &a_value);
GList *
-_gtk_tree_data_list_header_new (gint n_columns,
+_gtk_tree_data_list_header_new (int n_columns,
GType *types)
{
GList *retval = NULL;
- gint i;
+ int i;
for (i = 0; i < n_columns; i ++)
{
GtkTreeDataSortHeader *
_gtk_tree_data_list_get_header (GList *header_list,
- gint sort_column_id)
+ int sort_column_id)
{
GtkTreeDataSortHeader *header = NULL;
GList *
_gtk_tree_data_list_set_header (GList *header_list,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
GtkTreeDataList *next;
union {
- gint v_int;
+ int v_int;
gint8 v_char;
guint8 v_uchar;
guint v_uint;
typedef struct _GtkTreeDataSortHeader
{
- gint sort_column_id;
+ int sort_column_id;
GtkTreeIterCompareFunc func;
gpointer data;
GDestroyNotify destroy;
GType type);
/* Header code */
-gint _gtk_tree_data_list_compare_func (GtkTreeModel *model,
+int _gtk_tree_data_list_compare_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data);
-GList * _gtk_tree_data_list_header_new (gint n_columns,
+GList * _gtk_tree_data_list_header_new (int n_columns,
GType *types);
void _gtk_tree_data_list_header_free (GList *header_list);
GtkTreeDataSortHeader *_gtk_tree_data_list_get_header (GList *header_list,
- gint sort_column_id);
+ int sort_column_id);
GList *_gtk_tree_data_list_set_header (GList *header_list,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy);
GdkContentProvider *content;
GtkTreeRowData *trd;
gchar *path_str;
- gint len;
- gint struct_size;
+ int len;
+ int struct_size;
g_return_val_if_fail (GTK_IS_TREE_MODEL (tree_model), FALSE);
g_return_val_if_fail (path != NULL, FALSE);
* GtkTreeModel *list_store;
* GtkTreeIter iter;
* gboolean valid;
- * gint row_count = 0;
+ * int row_count = 0;
*
* // make a new list_store
* list_store = gtk_list_store_new (N_COLUMNS,
* while (valid)
* {
* gchar *str_data;
- * gint int_data;
+ * int int_data;
*
* // Make sure you terminate calls to gtk_tree_model_get() with a “-1” value
* gtk_tree_model_get (list_store, &iter,
struct _GtkTreePath
{
- gint depth; /* Number of elements */
- gint alloc; /* Number of allocated elements */
- gint *indices;
+ int depth; /* Number of elements */
+ int alloc; /* Number of allocated elements */
+ int *indices;
};
typedef struct
static void gtk_tree_row_ref_reordered (RowRefList *refs,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order);
+ int *new_order);
GType
gtk_tree_model_get_type (void)
void (* rows_reordered_callback) (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order);
+ int *new_order);
GObject *model = g_value_get_object (param_values + 0);
GtkTreePath *path = (GtkTreePath *)g_value_get_boxed (param_values + 1);
GtkTreeIter *iter = (GtkTreeIter *)g_value_get_boxed (param_values + 2);
- gint *new_order = (gint *)g_value_get_pointer (param_values + 3);
+ int *new_order = (int *)g_value_get_pointer (param_values + 3);
/* first, we need to update internal row references */
gtk_tree_row_ref_reordered ((RowRefList *)g_object_get_data (model, ROW_REF_DATA_STRING),
GtkTreePath *retval;
const gchar *orig_path = path;
gchar *ptr;
- gint i;
+ int i;
g_return_val_if_fail (path != NULL, NULL);
g_return_val_if_fail (*path != '\000', NULL);
* Returns: A newly created #GtkTreePath-struct
*/
GtkTreePath *
-gtk_tree_path_new_from_indices (gint first_index,
+gtk_tree_path_new_from_indices (int first_index,
...)
{
int arg;
while (arg != -1)
{
gtk_tree_path_append_index (path, arg);
- arg = va_arg (args, gint);
+ arg = va_arg (args, int);
}
va_end (args);
* Returns: A newly created #GtkTreePath-struct
*/
GtkTreePath *
-gtk_tree_path_new_from_indicesv (gint *indices,
+gtk_tree_path_new_from_indicesv (int *indices,
gsize length)
{
GtkTreePath *path;
path = gtk_tree_path_new ();
path->alloc = length;
path->depth = length;
- path->indices = g_new (gint, length);
- memcpy (path->indices, indices, length * sizeof (gint));
+ path->indices = g_new (int, length);
+ memcpy (path->indices, indices, length * sizeof (int));
return path;
}
gtk_tree_path_to_string (GtkTreePath *path)
{
gchar *retval, *ptr, *end;
- gint i, n;
+ int i, n;
g_return_val_if_fail (path != NULL, NULL);
*/
void
gtk_tree_path_append_index (GtkTreePath *path,
- gint index_)
+ int index_)
{
g_return_if_fail (path != NULL);
g_return_if_fail (index_ >= 0);
if (path->depth == path->alloc)
{
path->alloc = MAX (path->alloc * 2, 1);
- path->indices = g_renew (gint, path->indices, path->alloc);
+ path->indices = g_renew (int, path->indices, path->alloc);
}
path->depth += 1;
*/
void
gtk_tree_path_prepend_index (GtkTreePath *path,
- gint index)
+ int index)
{
if (path->depth == path->alloc)
{
- gint *indices;
+ int *indices;
path->alloc = MAX (path->alloc * 2, 1);
- indices = g_new (gint, path->alloc);
- memcpy (indices + 1, path->indices, path->depth * sizeof (gint));
+ indices = g_new (int, path->alloc);
+ memcpy (indices + 1, path->indices, path->depth * sizeof (int));
g_free (path->indices);
path->indices = indices;
}
else if (path->depth > 0)
- memmove (path->indices + 1, path->indices, path->depth * sizeof (gint));
+ memmove (path->indices + 1, path->indices, path->depth * sizeof (int));
path->depth += 1;
path->indices[0] = index;
*
* Returns: The depth of @path
*/
-gint
+int
gtk_tree_path_get_depth (GtkTreePath *path)
{
g_return_val_if_fail (path != NULL, 0);
*
* Returns: The current indices, or %NULL
*/
-gint *
+int *
gtk_tree_path_get_indices (GtkTreePath *path)
{
g_return_val_if_fail (path != NULL, NULL);
* Returns: (array length=depth) (transfer none): The current
* indices, or %NULL
*/
-gint *
+int *
gtk_tree_path_get_indices_with_depth (GtkTreePath *path,
- gint *depth)
+ int *depth)
{
g_return_val_if_fail (path != NULL, NULL);
retval = g_slice_new (GtkTreePath);
retval->depth = path->depth;
retval->alloc = retval->depth;
- retval->indices = g_new (gint, path->alloc);
- memcpy (retval->indices, path->indices, path->depth * sizeof (gint));
+ retval->indices = g_new (int, path->alloc);
+ memcpy (retval->indices, path->indices, path->depth * sizeof (int));
return retval;
}
*
* Returns: the relative positions of @a and @b
*/
-gint
+int
gtk_tree_path_compare (const GtkTreePath *a,
const GtkTreePath *b)
{
- gint p = 0, q = 0;
+ int p = 0, q = 0;
g_return_val_if_fail (a != NULL, 0);
g_return_val_if_fail (b != NULL, 0);
gtk_tree_path_is_ancestor (GtkTreePath *path,
GtkTreePath *descendant)
{
- gint i;
+ int i;
g_return_val_if_fail (path != NULL, FALSE);
g_return_val_if_fail (descendant != NULL, FALSE);
gtk_tree_path_is_descendant (GtkTreePath *path,
GtkTreePath *ancestor)
{
- gint i;
+ int i;
g_return_val_if_fail (path != NULL, FALSE);
g_return_val_if_fail (ancestor != NULL, FALSE);
*
* Returns: the number of columns
*/
-gint
+int
gtk_tree_model_get_n_columns (GtkTreeModel *tree_model)
{
GtkTreeModelIface *iface;
*/
GType
gtk_tree_model_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ int index)
{
GtkTreeModelIface *iface;
void
gtk_tree_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkTreeModelIface *iface;
*
* Returns: the number of children of @iter
*/
-gint
+int
gtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
GtkTreeModelIface *iface;
GtkTreeIter *iter,
va_list var_args)
{
- gint column;
+ int column;
g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
g_return_if_fail (iter != NULL);
- column = va_arg (var_args, gint);
+ column = va_arg (var_args, int);
while (column != -1)
{
g_value_unset (&value);
- column = va_arg (var_args, gint);
+ column = va_arg (var_args, int);
}
}
gtk_tree_model_rows_reordered (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order)
+ int *new_order)
{
g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
g_return_if_fail (new_order != NULL);
gtk_tree_model_rows_reordered_with_length (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
- gint length)
+ int *new_order,
+ int length)
{
g_return_if_fail (GTK_IS_TREE_MODEL (tree_model));
g_return_if_fail (new_order != NULL);
static void gtk_tree_row_reference_unref_path (GtkTreePath *path,
GtkTreeModel *model,
- gint depth);
+ int depth);
G_DEFINE_BOXED_TYPE (GtkTreeRowReference, gtk_tree_row_reference,
if (reference->path->depth >= path->depth)
{
- gint i;
+ int i;
gboolean ancestor = TRUE;
for (i = 0; i < path->depth - 1; i ++)
if (reference->path)
{
- gint i;
+ int i;
if (path->depth > reference->path->depth)
goto next;
gtk_tree_row_ref_reordered (RowRefList *refs,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order)
+ int *new_order)
{
GSList *tmp_list;
- gint length;
+ int length;
if (refs == NULL)
return;
if ((reference->path) &&
(gtk_tree_path_is_ancestor (path, reference->path)))
{
- gint ref_depth = gtk_tree_path_get_depth (reference->path);
- gint depth = gtk_tree_path_get_depth (path);
+ int ref_depth = gtk_tree_path_get_depth (reference->path);
+ int depth = gtk_tree_path_get_depth (path);
if (ref_depth > depth)
{
- gint i;
- gint *indices = gtk_tree_path_get_indices (reference->path);
+ int i;
+ int *indices = gtk_tree_path_get_indices (reference->path);
for (i = 0; i < length; i++)
{
gtk_tree_row_reference_unref_path_helper (GtkTreePath *path,
GtkTreeModel *model,
GtkTreeIter *parent_iter,
- gint depth,
- gint current_depth)
+ int depth,
+ int current_depth)
{
GtkTreeIter iter;
static void
gtk_tree_row_reference_unref_path (GtkTreePath *path,
GtkTreeModel *model,
- gint depth)
+ int depth)
{
GtkTreeIter iter;
GtkTreeRowReference *reference;
RowRefList *refs;
GtkTreeIter parent_iter;
- gint i;
+ int i;
g_return_val_if_fail (G_IS_OBJECT (proxy), NULL);
g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);
gtk_tree_row_reference_reordered (GObject *proxy,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order)
+ int *new_order)
{
g_return_if_fail (G_IS_OBJECT (proxy));
*/
struct _GtkTreeIter
{
- gint stamp;
+ int stamp;
gpointer user_data;
gpointer user_data2;
gpointer user_data3;
void (* rows_reordered) (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order);
+ int *new_order);
/* Virtual Table */
GtkTreeModelFlags (* get_flags) (GtkTreeModel *tree_model);
- gint (* get_n_columns) (GtkTreeModel *tree_model);
+ int (* get_n_columns) (GtkTreeModel *tree_model);
GType (* get_column_type) (GtkTreeModel *tree_model,
- gint index_);
+ int index_);
gboolean (* get_iter) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreeIter *iter);
void (* get_value) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
gboolean (* iter_next) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreeIter *parent);
gboolean (* iter_has_child) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
- gint (* iter_n_children) (GtkTreeModel *tree_model,
+ int (* iter_n_children) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
gboolean (* iter_nth_child) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
gboolean (* iter_parent) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
GDK_AVAILABLE_IN_ALL
GtkTreePath *gtk_tree_path_new_from_string (const gchar *path);
GDK_AVAILABLE_IN_ALL
-GtkTreePath *gtk_tree_path_new_from_indices (gint first_index,
+GtkTreePath *gtk_tree_path_new_from_indices (int first_index,
...);
GDK_AVAILABLE_IN_ALL
-GtkTreePath *gtk_tree_path_new_from_indicesv (gint *indices,
+GtkTreePath *gtk_tree_path_new_from_indicesv (int *indices,
gsize length);
GDK_AVAILABLE_IN_ALL
gchar *gtk_tree_path_to_string (GtkTreePath *path);
GtkTreePath *gtk_tree_path_new_first (void);
GDK_AVAILABLE_IN_ALL
void gtk_tree_path_append_index (GtkTreePath *path,
- gint index_);
+ int index_);
GDK_AVAILABLE_IN_ALL
void gtk_tree_path_prepend_index (GtkTreePath *path,
- gint index_);
+ int index_);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_path_get_depth (GtkTreePath *path);
+int gtk_tree_path_get_depth (GtkTreePath *path);
GDK_AVAILABLE_IN_ALL
-gint *gtk_tree_path_get_indices (GtkTreePath *path);
+int *gtk_tree_path_get_indices (GtkTreePath *path);
GDK_AVAILABLE_IN_ALL
-gint *gtk_tree_path_get_indices_with_depth (GtkTreePath *path,
- gint *depth);
+int *gtk_tree_path_get_indices_with_depth (GtkTreePath *path,
+ int *depth);
GDK_AVAILABLE_IN_ALL
void gtk_tree_path_free (GtkTreePath *path);
GDK_AVAILABLE_IN_ALL
GType gtk_tree_path_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_path_compare (const GtkTreePath *a,
+int gtk_tree_path_compare (const GtkTreePath *a,
const GtkTreePath *b);
GDK_AVAILABLE_IN_ALL
void gtk_tree_path_next (GtkTreePath *path);
void gtk_tree_row_reference_reordered (GObject *proxy,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order);
+ int *new_order);
/* GtkTreeIter operations */
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
GtkTreeModelFlags gtk_tree_model_get_flags (GtkTreeModel *tree_model);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_model_get_n_columns (GtkTreeModel *tree_model);
+int gtk_tree_model_get_n_columns (GtkTreeModel *tree_model);
GDK_AVAILABLE_IN_ALL
GType gtk_tree_model_get_column_type (GtkTreeModel *tree_model,
- gint index_);
+ int index_);
/* Iterator movement */
GDK_AVAILABLE_IN_ALL
void gtk_tree_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_model_iter_previous (GtkTreeModel *tree_model,
gboolean gtk_tree_model_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
+int gtk_tree_model_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_model_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_model_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
void gtk_tree_model_rows_reordered (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order);
+ int *new_order);
GDK_AVAILABLE_IN_ALL
void gtk_tree_model_rows_reordered_with_length (GtkTreeModel *tree_model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
- gint length);
+ int *new_order,
+ int length);
G_END_DECLS
{
GtkTreeIter iter;
FilterLevel *children;
- gint offset;
- gint ref_count;
- gint ext_ref_count;
- gint zero_ref_count;
+ int offset;
+ int ref_count;
+ int ext_ref_count;
+ int zero_ref_count;
GSequenceIter *visible_siter; /* iter into visible_seq */
};
{
GSequence *seq;
GSequence *visible_seq;
- gint ref_count;
- gint ext_ref_count;
+ int ref_count;
+ int ext_ref_count;
FilterElt *parent_elt;
FilterLevel *parent_level;
gpointer root;
GtkTreePath *virtual_root;
- gint stamp;
+ int stamp;
guint child_flags;
- gint zero_ref_count;
- gint visible_column;
+ int zero_ref_count;
+ int visible_column;
GtkTreeModelFilterVisibleFunc visible_func;
gpointer visible_data;
GtkTreeModelFilterModifyFunc modify_func;
gpointer modify_data;
GDestroyNotify modify_destroy;
- gint modify_n_columns;
+ int modify_n_columns;
guint visible_method_set : 1;
guint modify_func_set : 1;
static void gtk_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
GtkTreePath *c_path,
GtkTreeIter *c_iter,
- gint *new_order,
+ int *new_order,
gpointer data);
/* GtkTreeModel interface */
static GtkTreeModelFlags gtk_tree_model_filter_get_flags (GtkTreeModel *model);
-static gint gtk_tree_model_filter_get_n_columns (GtkTreeModel *model);
+static int gtk_tree_model_filter_get_n_columns (GtkTreeModel *model);
static GType gtk_tree_model_filter_get_column_type (GtkTreeModel *model,
- gint index);
+ int index);
static gboolean gtk_tree_model_filter_get_iter_full (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreeIter *iter);
static void gtk_tree_model_filter_get_value (GtkTreeModel *model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
static gboolean gtk_tree_model_filter_iter_next (GtkTreeModel *model,
GtkTreeIter *iter);
GtkTreeIter *parent);
static gboolean gtk_tree_model_filter_iter_has_child (GtkTreeModel *model,
GtkTreeIter *iter);
-static gint gtk_tree_model_filter_iter_n_children (GtkTreeModel *model,
+static int gtk_tree_model_filter_iter_n_children (GtkTreeModel *model,
GtkTreeIter *iter);
static gboolean gtk_tree_model_filter_iter_nth_child (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
static gboolean gtk_tree_model_filter_iter_parent (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeIter *child);
GtkTreeModel *child_model,
GtkTreeIter *iter,
GValue *value,
- gint column);
+ int column);
static gboolean gtk_tree_model_filter_real_visible (GtkTreeModelFilter *filter,
GtkTreeModel *child_model,
GtkTreeIter *child_iter);
static FilterElt *gtk_tree_model_filter_insert_elt_in_level (GtkTreeModelFilter *filter,
GtkTreeIter *c_iter,
FilterLevel *level,
- gint offset,
- gint *index);
+ int offset,
+ int *index);
static FilterElt *gtk_tree_model_filter_fetch_child (GtkTreeModelFilter *filter,
FilterLevel *level,
- gint offset,
- gint *index);
+ int offset,
+ int *index);
static void gtk_tree_model_filter_remove_elt_from_level (GtkTreeModelFilter *filter,
FilterLevel *level,
FilterElt *elt);
g_slice_free (FilterElt, elt);
}
-static gint
+static int
filter_elt_cmp (gconstpointer a,
gconstpointer b,
gpointer user_data)
static FilterElt *
lookup_elt_with_offset (GSequence *seq,
- gint offset,
+ int offset,
GSequenceIter **ret_siter)
{
GSequenceIter *siter;
gpointer user_data)
{
FilterElt *elt = data;
- gint offset = GPOINTER_TO_INT (user_data);
+ int offset = GPOINTER_TO_INT (user_data);
if (elt->offset >= offset)
elt->offset++;
gpointer user_data)
{
FilterElt *elt = data;
- gint offset = GPOINTER_TO_INT (user_data);
+ int offset = GPOINTER_TO_INT (user_data);
if (elt->offset > offset)
elt->offset--;
FilterLevel *tmp_level;
FilterElt *tmp_elt;
GtkTreeIter f_iter;
- gint length = 0;
- gint i;
+ int length = 0;
+ int i;
gboolean empty = TRUE;
g_assert (filter->priv->child_model != NULL);
static void
gtk_tree_model_filter_level_transfer_first_ref_with_index (GtkTreeModelFilter *filter,
FilterLevel *level,
- gint from_index,
- gint to_index)
+ int from_index,
+ int to_index)
{
gtk_tree_model_filter_level_transfer_first_ref (filter, level,
g_sequence_get_iter_at_pos (level->seq, from_index),
GtkTreePath *root)
{
GtkTreePath *retval;
- gint i;
+ int i;
retval = gtk_tree_path_copy (root);
GtkTreePath *root)
{
GtkTreePath *retval;
- gint i;
- gint depth;
- gint *indices;
+ int i;
+ int depth;
+ int *indices;
if (gtk_tree_path_get_depth (src) <= gtk_tree_path_get_depth (root))
return NULL;
gtk_tree_model_filter_insert_elt_in_level (GtkTreeModelFilter *filter,
GtkTreeIter *c_iter,
FilterLevel *level,
- gint offset,
- gint *index)
+ int offset,
+ int *index)
{
FilterElt *elt;
GSequenceIter *siter;
static FilterElt *
gtk_tree_model_filter_fetch_child (GtkTreeModelFilter *filter,
FilterLevel *level,
- gint offset,
- gint *index)
+ int offset,
+ int *index)
{
- gint len;
+ int len;
GtkTreePath *c_path = NULL;
GtkTreeIter c_iter;
GtkTreePath *c_parent_path = NULL;
{
FilterElt *parent;
FilterLevel *parent_level;
- gint length, orig_level_ext_ref_count;
+ int length, orig_level_ext_ref_count;
GtkTreeIter iter;
GtkTreePath *path = NULL;
GSequenceIter *siter;
FilterElt dummy;
- gint i = 0, offset;
+ int i = 0, offset;
gboolean free_c_path = FALSE;
gboolean emit_row_inserted = FALSE;
if (gtk_tree_path_get_depth (filter->priv->virtual_root) >=
gtk_tree_path_get_depth (c_path))
{
- gint depth;
- gint *v_indices, *c_indices;
+ int depth;
+ int *v_indices, *c_indices;
gboolean common_prefix = TRUE;
depth = gtk_tree_path_get_depth (c_path) - 1;
gtk_tree_model_filter_virtual_root_deleted (GtkTreeModelFilter *filter,
GtkTreePath *c_path)
{
- gint i, nodes;
+ int i, nodes;
GtkTreePath *path;
FilterLevel *level = FILTER_LEVEL (filter->priv->root);
gtk_tree_model_filter_adjust_virtual_root (GtkTreeModelFilter *filter,
GtkTreePath *c_path)
{
- gint i;
- gint level;
- gint *v_indices, *c_indices;
+ int i;
+ int level;
+ int *v_indices, *c_indices;
gboolean common_prefix = TRUE;
level = gtk_tree_path_get_depth (c_path) - 1;
GSequenceIter *siter;
gboolean emit_child_toggled = FALSE;
gboolean emit_row_deleted = FALSE;
- gint offset;
- gint orig_level_ext_ref_count;
+ int offset;
+ int orig_level_ext_ref_count;
g_return_if_fail (c_path != NULL);
gtk_tree_model_filter_rows_reordered (GtkTreeModel *c_model,
GtkTreePath *c_path,
GtkTreeIter *c_iter,
- gint *new_order,
+ int *new_order,
gpointer data)
{
FilterElt *elt;
GSequence *tmp_seq;
GSequenceIter *tmp_end_iter;
GSequenceIter *old_first_siter = NULL;
- gint *tmp_array;
- gint i, elt_count;
- gint length;
+ int *tmp_array;
+ int i, elt_count;
+ int length;
g_return_if_fail (new_order != NULL);
if (filter->priv->virtual_root)
{
- gint new_pos = -1;
+ int new_pos = -1;
/* reorder root level of path */
for (i = 0; i < length; i++)
if (filter->priv->virtual_root &&
gtk_tree_path_is_ancestor (c_path, filter->priv->virtual_root))
{
- gint new_pos = -1;
- gint len;
- gint depth;
+ int new_pos = -1;
+ int len;
+ int depth;
GtkTreeIter real_c_iter;
depth = gtk_tree_path_get_depth (c_path);
tmp_seq = g_sequence_new (filter_elt_free);
tmp_end_iter = g_sequence_get_end_iter (tmp_seq);
- tmp_array = g_new (gint, g_sequence_get_length (level->visible_seq));
+ tmp_array = g_new (int, g_sequence_get_length (level->visible_seq));
elt_count = 0;
old_first_siter = g_sequence_get_iter_at_pos (level->seq, 0);
return 0;
}
-static gint
+static int
gtk_tree_model_filter_get_n_columns (GtkTreeModel *model)
{
GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
static GType
gtk_tree_model_filter_get_column_type (GtkTreeModel *model,
- gint index)
+ int index)
{
GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
GtkTreePath *path)
{
GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
- gint *indices;
+ int *indices;
FilterLevel *level;
FilterElt *elt;
- gint depth, i;
+ int depth, i;
GSequenceIter *siter;
g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
GtkTreePath *path)
{
GtkTreeModelFilter *filter = (GtkTreeModelFilter *)model;
- gint *indices;
+ int *indices;
FilterLevel *level;
FilterElt *elt;
GSequenceIter *siter;
- gint depth, i;
+ int depth, i;
g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (model), FALSE);
g_return_val_if_fail (filter->priv->child_model != NULL, FALSE);
while (level)
{
- gint index;
+ int index;
index = g_sequence_iter_get_position (elt->visible_siter);
gtk_tree_path_prepend_index (retval, index);
GtkTreeModel *child_model,
GtkTreeIter *iter,
GValue *value,
- gint column)
+ int column)
{
if (self->priv->modify_func)
{
static void
gtk_tree_model_filter_get_value (GtkTreeModel *model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkTreeModelFilter *filter = GTK_TREE_MODEL_FILTER (model);
return FALSE;
}
-static gint
+static int
gtk_tree_model_filter_iter_n_children (GtkTreeModel *model,
GtkTreeIter *iter)
{
gtk_tree_model_filter_iter_nth_child (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
FilterLevel *level;
GtkTreeIter children;
*/
void
gtk_tree_model_filter_set_modify_func (GtkTreeModelFilter *filter,
- gint n_columns,
+ int n_columns,
GType *types,
GtkTreeModelFilterModifyFunc func,
gpointer data,
/**
* gtk_tree_model_filter_set_visible_column:
* @filter: A #GtkTreeModelFilter
- * @column: A #gint which is the column containing the visible information
+ * @column: A #int which is the column containing the visible information
*
* Sets @column of the child_model to be the column where @filter should
* look for visibility information. @columns should be a column of type
*/
void
gtk_tree_model_filter_set_visible_column (GtkTreeModelFilter *filter,
- gint column)
+ int column)
{
g_return_if_fail (GTK_IS_TREE_MODEL_FILTER (filter));
g_return_if_fail (column >= 0);
gboolean build_levels,
gboolean fetch_children)
{
- gint *child_indices;
+ int *child_indices;
GtkTreePath *retval;
GtkTreePath *real_path;
FilterLevel *level;
FilterElt *tmp;
- gint i;
+ int i;
g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), NULL);
g_return_val_if_fail (filter->priv->child_model != NULL, NULL);
gtk_tree_model_filter_convert_path_to_child_path (GtkTreeModelFilter *filter,
GtkTreePath *filter_path)
{
- gint *filter_indices;
+ int *filter_indices;
GtkTreePath *retval;
FilterLevel *level;
- gint i;
+ int i;
g_return_val_if_fail (GTK_IS_TREE_MODEL_FILTER (filter), NULL);
g_return_val_if_fail (filter->priv->child_model != NULL, NULL);
typedef void (* GtkTreeModelFilterModifyFunc) (GtkTreeModel *model,
GtkTreeIter *iter,
GValue *value,
- gint column,
+ int column,
gpointer data);
typedef struct _GtkTreeModelFilter GtkTreeModelFilter;
GtkTreeModel *child_model,
GtkTreeIter *iter,
GValue *value,
- gint column);
+ int column);
/*< private >*/
GDestroyNotify destroy);
GDK_AVAILABLE_IN_ALL
void gtk_tree_model_filter_set_modify_func (GtkTreeModelFilter *filter,
- gint n_columns,
+ int n_columns,
GType *types,
GtkTreeModelFilterModifyFunc func,
gpointer data,
GDestroyNotify destroy);
GDK_AVAILABLE_IN_ALL
void gtk_tree_model_filter_set_visible_column (GtkTreeModelFilter *filter,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
GtkTreeModel *gtk_tree_model_filter_get_model (GtkTreeModelFilter *filter);
{
GtkTreeIter iter;
SortLevel *children;
- gint offset;
- gint ref_count;
- gint zero_ref_count;
- gint old_index; /* used while sorting */
+ int offset;
+ int ref_count;
+ int zero_ref_count;
+ int old_index; /* used while sorting */
GSequenceIter *siter; /* iter into seq */
};
struct _SortLevel
{
GSequence *seq;
- gint ref_count;
+ int ref_count;
SortElt *parent_elt;
SortLevel *parent_level;
};
gpointer sort_data;
GtkTreePath *parent_path;
- gint *parent_path_indices;
- gint parent_path_depth;
+ int *parent_path_indices;
+ int parent_path_depth;
};
/* Properties */
struct _GtkTreeModelSortPrivate
{
gpointer root;
- gint stamp;
+ int stamp;
guint child_flags;
GtkTreeModel *child_model;
- gint zero_ref_count;
+ int zero_ref_count;
/* sort information */
GList *sort_list;
- gint sort_column_id;
+ int sort_column_id;
GtkSortType order;
/* default sort */
static void gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
GtkTreePath *s_path,
GtkTreeIter *s_iter,
- gint *new_order,
+ int *new_order,
gpointer data);
/* TreeModel interface */
static GtkTreeModelFlags gtk_tree_model_sort_get_flags (GtkTreeModel *tree_model);
-static gint gtk_tree_model_sort_get_n_columns (GtkTreeModel *tree_model);
+static int gtk_tree_model_sort_get_n_columns (GtkTreeModel *tree_model);
static GType gtk_tree_model_sort_get_column_type (GtkTreeModel *tree_model,
- gint index);
+ int index);
static gboolean gtk_tree_model_sort_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreeIter *iter);
static void gtk_tree_model_sort_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
static gboolean gtk_tree_model_sort_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreeIter *parent);
static gboolean gtk_tree_model_sort_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gint gtk_tree_model_sort_iter_n_children (GtkTreeModel *tree_model,
+static int gtk_tree_model_sort_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gboolean gtk_tree_model_sort_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
static gboolean gtk_tree_model_sort_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
/* TreeSortable interface */
static gboolean gtk_tree_model_sort_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order);
static void gtk_tree_model_sort_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order);
static void gtk_tree_model_sort_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy);
GtkTreePath *child_path,
gboolean build_levels);
-static gint gtk_tree_model_sort_compare_func (gconstpointer a,
+static int gtk_tree_model_sort_compare_func (gconstpointer a,
gconstpointer b,
gpointer user_data);
-static gint gtk_tree_model_sort_offset_compare_func (gconstpointer a,
+static int gtk_tree_model_sort_offset_compare_func (gconstpointer a,
gconstpointer b,
gpointer user_data);
static void gtk_tree_model_sort_clear_cache_helper (GtkTreeModelSort *tree_model_sort,
gpointer user_data)
{
SortElt *elt = data;
- gint offset = GPOINTER_TO_INT (user_data);
+ int offset = GPOINTER_TO_INT (user_data);
if (elt->offset >= offset)
elt->offset++;
gpointer user_data)
{
SortElt *elt = data;
- gint offset = GPOINTER_TO_INT (user_data);
+ int offset = GPOINTER_TO_INT (user_data);
if (elt->offset > offset)
elt->offset--;
static SortElt *
lookup_elt_with_offset (GtkTreeModelSort *tree_model_sort,
SortLevel *level,
- gint offset,
+ int offset,
GSequenceIter **ret_siter)
{
GSequenceIter *siter, *end_siter;
gboolean free_s_path = FALSE;
- gint index = 0, old_index;
+ int index = 0, old_index;
g_return_if_fail (start_s_path != NULL || start_s_iter != NULL);
/* if the item moved, then emit rows_reordered */
if (old_index != index)
{
- gint *new_order;
- gint j;
+ int *new_order;
+ int j;
GtkTreePath *tmppath;
- new_order = g_new (gint, g_sequence_get_length (level->seq));
+ new_order = g_new (int, g_sequence_get_length (level->seq));
for (j = 0; j < g_sequence_get_length (level->seq); j++)
{
GtkTreeIter iter;
GtkTreeIter real_s_iter;
- gint i = 0;
+ int i = 0;
gboolean free_s_path = FALSE;
SortElt *elt;
SortLevel *level;
GtkTreeIter iter;
- gint offset;
+ int offset;
g_return_if_fail (s_path != NULL);
gtk_tree_model_sort_rows_reordered (GtkTreeModel *s_model,
GtkTreePath *s_path,
GtkTreeIter *s_iter,
- gint *new_order,
+ int *new_order,
gpointer data)
{
SortLevel *level;
GtkTreeIter iter;
GtkTreePath *path;
- gint *tmp_array;
+ int *tmp_array;
int i, length;
GSequenceIter *siter, *end_siter;
GtkTreeModelSort *tree_model_sort = GTK_TREE_MODEL_SORT (data);
siter != end_siter;
siter = g_sequence_iter_next (siter))
{
- gint j;
+ int j;
SortElt *elt = g_sequence_get (siter);
for (j = 0; j < length; j++)
return 0;
}
-static gint
+static int
gtk_tree_model_sort_get_n_columns (GtkTreeModel *tree_model)
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
static GType
gtk_tree_model_sort_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ int index)
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
GtkTreeModelSortPrivate *priv = tree_model_sort->priv;
- gint *indices;
+ int *indices;
SortElt *elt;
SortLevel *level;
- gint depth, i;
+ int depth, i;
GSequenceIter *siter;
g_return_val_if_fail (priv->child_model != NULL, FALSE);
while (level)
{
- gint index;
+ int index;
index = g_sequence_iter_get_position (elt->siter);
gtk_tree_path_prepend_index (retval, index);
static void
gtk_tree_model_sort_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
return gtk_tree_model_iter_has_child (priv->child_model, &child_iter);
}
-static gint
+static int
gtk_tree_model_sort_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
gtk_tree_model_sort_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *) tree_model;
SortLevel *level;
/* Sortable interface */
static gboolean
gtk_tree_model_sort_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order)
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *)sortable;
static void
gtk_tree_model_sort_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order)
{
GtkTreeModelSort *tree_model_sort = (GtkTreeModelSort *)sortable;
static void
gtk_tree_model_sort_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
}
/* sorting code - private */
-static gint
+static int
gtk_tree_model_sort_compare_func (gconstpointer a,
gconstpointer b,
gpointer user_data)
const SortElt *sb = b;
GtkTreeIter iter_a, iter_b;
- gint retval;
+ int retval;
if (GTK_TREE_MODEL_SORT_CACHE_CHILD_ITERS (tree_model_sort))
{
return retval;
}
-static gint
+static int
gtk_tree_model_sort_offset_compare_func (gconstpointer a,
gconstpointer b,
gpointer user_data)
{
- gint retval;
+ int retval;
const SortElt *sa = (SortElt *)a;
const SortElt *sb = (SortElt *)b;
gboolean emit_reordered)
{
GtkTreeModelSortPrivate *priv = tree_model_sort->priv;
- gint i;
+ int i;
GSequenceIter *begin_siter, *end_siter, *siter;
SortElt *begin_elt;
- gint *new_order;
+ int *new_order;
GtkTreeIter iter;
GtkTreePath *path;
free_sort_data (&data);
- new_order = g_new (gint, g_sequence_get_length (level->seq));
+ new_order = g_new (int, g_sequence_get_length (level->seq));
i = 0;
end_siter = g_sequence_get_end_iter (level->seq);
GtkTreeModelSortPrivate *priv = tree_model_sort->priv;
SortElt *elt;
SortData data;
- gint offset;
+ int offset;
elt = sort_elt_new ();
if (child_model)
{
GType *types;
- gint i, n_columns;
+ int i, n_columns;
priv->changed_id =
g_signal_connect (child_model, "row-changed",
gboolean build_levels)
{
GtkTreeModelSortPrivate *priv = tree_model_sort->priv;
- gint *child_indices;
+ int *child_indices;
GtkTreePath *retval;
SortLevel *level;
- gint i;
+ int i;
g_return_val_if_fail (priv->child_model != NULL, NULL);
g_return_val_if_fail (child_path != NULL, NULL);
GtkTreePath *sorted_path)
{
GtkTreeModelSortPrivate *priv = tree_model_sort->priv;
- gint *sorted_indices;
+ int *sorted_indices;
GtkTreePath *retval;
SortLevel *level;
- gint i;
+ int i;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT (tree_model_sort), NULL);
g_return_val_if_fail (priv->child_model != NULL, NULL);
GtkTreeModelSortPrivate *priv = tree_model_sort->priv;
GtkTreeIter iter;
SortLevel *new_level;
- gint length = 0;
- gint i;
+ int length = 0;
+ int i;
g_assert (priv->child_model != NULL);
GtkTreeIter *iter,
GtkTreePopover *popover)
{
- gint *indices, depth, index;
+ int *indices, depth, index;
GtkWidget *item;
GtkWidget *box;
{
gboolean is_separator = FALSE;
GtkWidget *item;
- gint *indices, depth, index;
+ int *indices, depth, index;
item = gtk_tree_popover_get_path_item (popover, path);
row_reordered_cb (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
GtkTreePopover *popover)
{
rebuild_menu (popover);
void _gtk_tree_view_column_set_tree_view (GtkTreeViewColumn *column,
GtkTreeView *tree_view);
-gint _gtk_tree_view_column_request_width (GtkTreeViewColumn *tree_column);
+int _gtk_tree_view_column_request_width (GtkTreeViewColumn *tree_column);
void _gtk_tree_view_column_allocate (GtkTreeViewColumn *tree_column,
int x_offset,
int width,
GtkCellRenderer *_gtk_tree_view_column_get_cell_at_pos (GtkTreeViewColumn *column,
GdkRectangle *cell_area,
GdkRectangle *background_area,
- gint x,
- gint y);
+ int x,
+ int y);
gboolean _gtk_tree_view_column_is_blank_at_pos (GtkTreeViewColumn *column,
GdkRectangle *cell_area,
GdkRectangle *background_area,
- gint x,
- gint y);
+ int x,
+ int y);
void gtk_tree_view_column_cell_snapshot (GtkTreeViewColumn *tree_column,
GtkSnapshot *snapshot,
gboolean _gtk_tree_view_column_cell_get_dirty (GtkTreeViewColumn *tree_column);
void _gtk_tree_view_column_push_padding (GtkTreeViewColumn *column,
- gint padding);
-gint _gtk_tree_view_column_get_requested_width (GtkTreeViewColumn *column);
-gint _gtk_tree_view_column_get_drag_x (GtkTreeViewColumn *column);
+ int padding);
+int _gtk_tree_view_column_get_requested_width (GtkTreeViewColumn *column);
+int _gtk_tree_view_column_get_drag_x (GtkTreeViewColumn *column);
GtkCellAreaContext *_gtk_tree_view_column_get_context (GtkTreeViewColumn *column);
gboolean _gtk_tree_view_column_coords_in_resize_rect (GtkTreeViewColumn *column,
double x,
#include "gtkdebug.h"
static GtkTreeRBNode *gtk_tree_rbnode_new (GtkTreeRBTree *tree,
- gint height);
+ int height);
static void gtk_tree_rbnode_free (GtkTreeRBNode *node);
static void gtk_tree_rbnode_rotate_left (GtkTreeRBTree *tree,
GtkTreeRBNode *node);
static GtkTreeRBNode *
gtk_tree_rbnode_new (GtkTreeRBTree *tree,
- gint height)
+ int height)
{
GtkTreeRBNode *node = g_slice_new (GtkTreeRBNode);
gtk_tree_rbnode_rotate_left (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint node_height, right_height;
+ int node_height, right_height;
GtkTreeRBNode *right;
g_return_if_fail (!gtk_tree_rbtree_is_nil (node));
gtk_tree_rbnode_rotate_right (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint node_height, left_height;
+ int node_height, left_height;
GtkTreeRBNode *left;
g_return_if_fail (!gtk_tree_rbtree_is_nil (node));
GtkTreeRBNode *
gtk_tree_rbtree_insert_after (GtkTreeRBTree *tree,
GtkTreeRBNode *current,
- gint height,
+ int height,
gboolean valid)
{
GtkTreeRBNode *node;
GtkTreeRBNode *
gtk_tree_rbtree_insert_before (GtkTreeRBTree *tree,
GtkTreeRBNode *current,
- gint height,
+ int height,
gboolean valid)
{
GtkTreeRBNode *node;
GtkTreeRBNode *
gtk_tree_rbtree_find_count (GtkTreeRBTree *tree,
- gint count)
+ int count)
{
GtkTreeRBNode *node;
void
gtk_tree_rbtree_node_set_height (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint height)
+ int height)
{
- gint diff = height - GTK_TREE_RBNODE_GET_HEIGHT (node);
+ int diff = height - GTK_TREE_RBNODE_GET_HEIGHT (node);
if (diff == 0)
return;
void
gtk_tree_rbtree_set_fixed_height (GtkTreeRBTree *tree,
- gint height,
+ int height,
gboolean mark_valid)
{
GtkTreeRBNode *node;
*/
void
gtk_tree_rbtree_reorder (GtkTreeRBTree *tree,
- gint *new_order,
- gint length)
+ int *new_order,
+ int length)
{
GtkTreeRBNode **nodes;
GtkTreeRBNode *node;
- gint i, j;
+ int i, j;
g_return_if_fail (tree != NULL);
g_return_if_fail (length > 0);
return FALSE;
}
-gint
+int
gtk_tree_rbtree_node_find_offset (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
GtkTreeRBNode *last;
- gint retval;
+ int retval;
g_assert (node);
g_assert (node->left);
return retval;
}
-static gint
+static int
gtk_rbtree_real_find_offset (GtkTreeRBTree *tree,
- gint height,
+ int height,
GtkTreeRBTree **new_tree,
GtkTreeRBNode **new_node)
{
return (height - tmp_node->left->offset);
}
-gint
+int
gtk_tree_rbtree_find_offset (GtkTreeRBTree *tree,
- gint height,
+ int height,
GtkTreeRBTree **new_tree,
GtkTreeRBNode **new_node)
{
GtkTreeRBNode *node)
{
GtkTreeRBNode *x, *y;
- gint y_height;
+ int y_height;
guint y_total_count;
g_return_if_fail (tree != NULL);
if (y != node)
{
- gint node_height, node_total_count;
+ int node_height, node_total_count;
/* We want to see how much we remove from the aggregate values.
* This is all the children we remove plus the node's values.
}
}
-gint
+int
gtk_tree_rbtree_get_depth (GtkTreeRBTree *tree)
{
GtkTreeRBTree *tmp_tree;
- gint depth = 0;
+ int depth = 0;
tmp_tree = tree->parent_tree;
while (tmp_tree)
return res;
}
-static gint
+static int
_count_nodes (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint res;
+ int res;
if (gtk_tree_rbtree_is_nil (node))
return 0;
gtk_tree_rbtree_test_height (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint computed_offset = 0;
+ int computed_offset = 0;
/* This whole test is sort of a useless truism. */
static void
gtk_tree_rbtree_test_dirty (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint expected_dirtyness)
+ int expected_dirtyness)
{
g_assert (node);
gtk_tree_rbtree_debug_spew_helper (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
GString *s,
- gint depth)
+ int depth)
{
- gint i;
+ int i;
for (i = 0; i < depth; i++)
g_string_append (s, "\t");
/* count is the number of nodes beneath us, plus 1 for ourselves.
* i.e. node->left->count + node->right->count + 1
*/
- gint count;
+ int count;
GtkTreeRBNode *left;
GtkTreeRBNode *right;
* of all trees in ->children, iff children exists because
* the thing is expanded.
*/
- gint offset;
+ int offset;
/* Child trees */
GtkTreeRBTree *children;
void gtk_tree_rbtree_destroy (GtkTreeRBTree *tree);
GtkTreeRBNode * gtk_tree_rbtree_insert_before (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint height,
+ int height,
gboolean valid);
GtkTreeRBNode * gtk_tree_rbtree_insert_after (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint height,
+ int height,
gboolean valid);
void gtk_tree_rbtree_remove_node (GtkTreeRBTree *tree,
GtkTreeRBNode *node);
gboolean gtk_tree_rbtree_is_nil (GtkTreeRBNode *node);
void gtk_tree_rbtree_reorder (GtkTreeRBTree *tree,
- gint *new_order,
- gint length);
+ int *new_order,
+ int length);
gboolean gtk_tree_rbtree_contains (GtkTreeRBTree *tree,
GtkTreeRBTree *potential_child);
GtkTreeRBNode * gtk_tree_rbtree_find_count (GtkTreeRBTree *tree,
- gint count);
+ int count);
void gtk_tree_rbtree_node_set_height (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint height);
+ int height);
void gtk_tree_rbtree_node_mark_invalid (GtkTreeRBTree *tree,
GtkTreeRBNode *node);
void gtk_tree_rbtree_node_mark_valid (GtkTreeRBTree *tree,
void gtk_tree_rbtree_column_invalid (GtkTreeRBTree *tree);
void gtk_tree_rbtree_mark_invalid (GtkTreeRBTree *tree);
void gtk_tree_rbtree_set_fixed_height (GtkTreeRBTree *tree,
- gint height,
+ int height,
gboolean mark_valid);
-gint gtk_tree_rbtree_node_find_offset (GtkTreeRBTree *tree,
+int gtk_tree_rbtree_node_find_offset (GtkTreeRBTree *tree,
GtkTreeRBNode *node);
guint gtk_tree_rbtree_node_get_index (GtkTreeRBTree *tree,
GtkTreeRBNode *node);
guint index,
GtkTreeRBTree **new_tree,
GtkTreeRBNode **new_node);
-gint gtk_tree_rbtree_find_offset (GtkTreeRBTree *tree,
- gint offset,
+int gtk_tree_rbtree_find_offset (GtkTreeRBTree *tree,
+ int offset,
GtkTreeRBTree **new_tree,
GtkTreeRBNode **new_node);
void gtk_tree_rbtree_traverse (GtkTreeRBTree *tree,
GtkTreeRBTree **new_tree,
GtkTreeRBNode **new_node);
-gint gtk_tree_rbtree_get_depth (GtkTreeRBTree *tree);
+int gtk_tree_rbtree_get_depth (GtkTreeRBTree *tree);
G_END_DECLS
};
static void gtk_tree_selection_finalize (GObject *object);
-static gint gtk_tree_selection_real_select_all (GtkTreeSelection *selection);
-static gint gtk_tree_selection_real_unselect_all (GtkTreeSelection *selection);
-static gint gtk_tree_selection_real_select_node (GtkTreeSelection *selection,
+static int gtk_tree_selection_real_select_all (GtkTreeSelection *selection);
+static int gtk_tree_selection_real_unselect_all (GtkTreeSelection *selection);
+static int gtk_tree_selection_real_select_node (GtkTreeSelection *selection,
GtkTreeRBTree *tree,
GtkTreeRBNode *node,
gboolean select);
{
GtkTreeRBTree *tree = NULL;
GtkTreeRBNode *node = NULL;
- gint selected = FALSE;
+ int selected = FALSE;
GtkTreePath *anchor_path = NULL;
anchor_path = _gtk_tree_view_get_anchor_path (selection->tree_view);
GtkTreeRBNode *node,
gpointer data)
{
- gint *count = (gint *)data;
+ int *count = (int *)data;
g_return_if_fail (node != NULL);
*
* Returns: The number of rows selected.
**/
-gint
+int
gtk_tree_selection_count_selected_rows (GtkTreeSelection *selection)
{
- gint count = 0;
+ int count = 0;
GtkTreeRBTree *tree;
g_return_val_if_fail (GTK_IS_TREE_SELECTION (selection), 0);
/* Wish I was in python, right now... */
struct _TempTuple {
GtkTreeSelection *selection;
- gint dirty;
+ int dirty;
};
static void
/* We have a real_{un,}select_all function that doesn't emit the signal, so we
* can use it in other places without fear of the signal being emitted.
*/
-static gint
+static int
gtk_tree_selection_real_select_all (GtkTreeSelection *selection)
{
struct _TempTuple *tuple;
RANGE_UNSELECT
};
-static gint
+static int
gtk_tree_selection_real_modify_range (GtkTreeSelection *selection,
- gint mode,
+ int mode,
GtkTreePath *start_path,
GtkTreePath *end_path)
{
GtkTreeSelectMode mode,
gboolean override_browse_mode)
{
- gint flags;
- gint dirty = FALSE;
+ int flags;
+ int dirty = FALSE;
GtkTreePath *anchor_path = NULL;
if (selection->type == GTK_SELECTION_NONE)
/* NOTE: Any {un,}selection ever done _MUST_ be done through this function!
*/
-static gint
+static int
gtk_tree_selection_real_select_node (GtkTreeSelection *selection,
GtkTreeRBTree *tree,
GtkTreeRBNode *node,
GList * gtk_tree_selection_get_selected_rows (GtkTreeSelection *selection,
GtkTreeModel **model);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_selection_count_selected_rows (GtkTreeSelection *selection);
+int gtk_tree_selection_count_selected_rows (GtkTreeSelection *selection);
GDK_AVAILABLE_IN_ALL
void gtk_tree_selection_selected_foreach (GtkTreeSelection *selection,
GtkTreeSelectionForeachFunc func,
**/
gboolean
gtk_tree_sortable_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order)
{
GtkTreeSortableIface *iface;
*/
void
gtk_tree_sortable_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order)
{
GtkTreeSortableIface *iface;
*/
void
gtk_tree_sortable_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc sort_func,
gpointer user_data,
GDestroyNotify destroy)
* Returns: a negative integer, zero or a positive integer depending on whether
* @a sorts before, with or after @b
*/
-typedef gint (* GtkTreeIterCompareFunc) (GtkTreeModel *model,
- GtkTreeIter *a,
- GtkTreeIter *b,
- gpointer user_data);
+typedef int (* GtkTreeIterCompareFunc) (GtkTreeModel *model,
+ GtkTreeIter *a,
+ GtkTreeIter *b,
+ gpointer user_data);
/**
/* virtual table */
gboolean (* get_sort_column_id) (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order);
void (* set_sort_column_id) (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order);
void (* set_sort_func) (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc sort_func,
gpointer user_data,
GDestroyNotify destroy);
void gtk_tree_sortable_sort_column_changed (GtkTreeSortable *sortable);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_sortable_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order);
GDK_AVAILABLE_IN_ALL
void gtk_tree_sortable_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order);
GDK_AVAILABLE_IN_ALL
void gtk_tree_sortable_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc sort_func,
gpointer user_data,
GDestroyNotify destroy);
struct _GtkTreeStorePrivate
{
- gint stamp;
+ int stamp;
GtkSortType order;
gpointer root;
gpointer last;
- gint n_columns;
- gint sort_column_id;
+ int n_columns;
+ int sort_column_id;
GList *sort_list;
GType *column_headers;
GtkTreeIterCompareFunc default_sort_func;
static void gtk_tree_store_buildable_init (GtkBuildableIface *iface);
static void gtk_tree_store_finalize (GObject *object);
static GtkTreeModelFlags gtk_tree_store_get_flags (GtkTreeModel *tree_model);
-static gint gtk_tree_store_get_n_columns (GtkTreeModel *tree_model);
+static int gtk_tree_store_get_n_columns (GtkTreeModel *tree_model);
static GType gtk_tree_store_get_column_type (GtkTreeModel *tree_model,
- gint index);
+ int index);
static gboolean gtk_tree_store_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreeIter *iter);
static void gtk_tree_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
static gboolean gtk_tree_store_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreeIter *parent);
static gboolean gtk_tree_store_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gint gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
+static int gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gboolean gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
static gboolean gtk_tree_store_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
static void gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
- gint n_columns);
+ int n_columns);
static void gtk_tree_store_set_column_type (GtkTreeStore *tree_store,
- gint column,
+ int column,
GType type);
static void gtk_tree_store_increment_stamp (GtkTreeStore *tree_store);
static void gtk_tree_store_sort (GtkTreeStore *tree_store);
static void gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint column,
+ int column,
gboolean emit_signal);
static gboolean gtk_tree_store_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order);
static void gtk_tree_store_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order);
static void gtk_tree_store_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy);
*
* As an example, `gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING,
* GDK_TYPE_TEXTURE);` will create a new #GtkTreeStore with three columns, of type
- * #gint, #gchararray, and #GdkTexture respectively.
+ * #int, #gchararray, and #GdkTexture respectively.
*
* Returns: a new #GtkTreeStore
**/
GtkTreeStore *
-gtk_tree_store_new (gint n_columns,
+gtk_tree_store_new (int n_columns,
...)
{
GtkTreeStore *retval;
va_list args;
- gint i;
+ int i;
g_return_val_if_fail (n_columns > 0, NULL);
* Returns: (transfer full): a new #GtkTreeStore
**/
GtkTreeStore *
-gtk_tree_store_newv (gint n_columns,
+gtk_tree_store_newv (int n_columns,
GType *types)
{
GtkTreeStore *retval;
- gint i;
+ int i;
g_return_val_if_fail (n_columns > 0, NULL);
**/
void
gtk_tree_store_set_column_types (GtkTreeStore *tree_store,
- gint n_columns,
+ int n_columns,
GType *types)
{
- gint i;
+ int i;
g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
g_return_if_fail (tree_store->priv->columns_dirty == 0);
static void
gtk_tree_store_set_n_columns (GtkTreeStore *tree_store,
- gint n_columns)
+ int n_columns)
{
GtkTreeStorePrivate *priv = tree_store->priv;
int i;
**/
static void
gtk_tree_store_set_column_type (GtkTreeStore *tree_store,
- gint column,
+ int column,
GType type)
{
GtkTreeStorePrivate *priv = tree_store->priv;
return GTK_TREE_MODEL_ITERS_PERSIST;
}
-static gint
+static int
gtk_tree_store_get_n_columns (GtkTreeModel *tree_model)
{
GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
static GType
gtk_tree_store_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ int index)
{
GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreeIter parent;
- gint *indices;
- gint depth, i;
+ int *indices;
+ int depth, i;
priv->columns_dirty = TRUE;
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreePath *retval;
GNode *tmp_node;
- gint i = 0;
+ int i = 0;
g_return_val_if_fail (iter->user_data != NULL, NULL);
g_return_val_if_fail (iter->stamp == priv->stamp, NULL);
static void
gtk_tree_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreeDataList *list;
- gint tmp_column = column;
+ int tmp_column = column;
g_return_if_fail (column < priv->n_columns);
g_return_if_fail (VALID_ITER (iter, tree_store));
return G_NODE (iter->user_data)->children != NULL;
}
-static gint
+static int
gtk_tree_store_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GNode *node;
- gint i = 0;
+ int i = 0;
g_return_val_if_fail (iter == NULL || iter->user_data != NULL, 0);
gtk_tree_store_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
GtkTreeStore *tree_store = (GtkTreeStore *) tree_model;
GtkTreeStorePrivate *priv = tree_store->priv;
static gboolean
gtk_tree_store_real_set_value (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value,
gboolean sort)
{
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreeDataList *list;
GtkTreeDataList *prev;
- gint old_column = column;
+ int old_column = column;
GValue real_value = G_VALUE_INIT;
gboolean converted = FALSE;
gboolean retval = FALSE;
void
gtk_tree_store_set_value (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
GtkTreeIter *iter,
gboolean *emit_signal,
gboolean *maybe_need_sort,
- gint *columns,
+ int *columns,
GValue *values,
- gint n_values)
+ int n_values)
{
GtkTreeStorePrivate *priv = tree_store->priv;
- gint i;
+ int i;
GtkTreeIterCompareFunc func = NULL;
func = gtk_tree_store_get_compare_func (tree_store);
va_list var_args)
{
GtkTreeStorePrivate *priv = tree_store->priv;
- gint column;
+ int column;
GtkTreeIterCompareFunc func = NULL;
- column = va_arg (var_args, gint);
+ column = va_arg (var_args, int);
func = gtk_tree_store_get_compare_func (tree_store);
if (func != _gtk_tree_data_list_compare_func)
g_value_unset (&value);
- column = va_arg (var_args, gint);
+ column = va_arg (var_args, int);
}
}
void
gtk_tree_store_set_valuesv (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint *columns,
+ int *columns,
GValue *values,
- gint n_values)
+ int n_values)
{
GtkTreeStorePrivate *priv = tree_store->priv;
gboolean emit_signal = FALSE;
gtk_tree_store_insert (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint position)
+ int position)
{
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreePath *path;
gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint position,
+ int position,
...)
{
GtkTreeStorePrivate *priv = tree_store->priv;
gtk_tree_store_insert_with_valuesv (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint position,
- gint *columns,
+ int position,
+ int *columns,
GValue *values,
- gint n_values)
+ int n_values)
{
GtkTreeStorePrivate *priv = tree_store->priv;
GtkTreePath *path;
*
* Returns: The depth of @iter
**/
-gint
+int
gtk_tree_store_iter_depth (GtkTreeStore *tree_store,
GtkTreeIter *iter)
{
GtkTreeDataList *copy_prev = NULL;
GtkTreeDataList *copy_iter = NULL;
GtkTreePath *path;
- gint col;
+ int col;
col = 0;
while (dl)
/* Sorting and reordering */
typedef struct _SortTuple
{
- gint offset;
+ int offset;
GNode *node;
} SortTuple;
/* Reordering */
-static gint
+static int
gtk_tree_store_reorder_func (gconstpointer a,
gconstpointer b,
gpointer user_data)
void
gtk_tree_store_reorder (GtkTreeStore *tree_store,
GtkTreeIter *parent,
- gint *new_order)
+ int *new_order)
{
- gint i, length = 0;
+ int i, length = 0;
GNode *level, *node;
GtkTreePath *path;
SortTuple *sort_array;
{
GNode *tmp, *node_a, *node_b, *parent_node;
GNode *a_prev, *a_next, *b_prev, *b_next;
- gint i, a_count, b_count, length, *order;
+ int i, a_count, b_count, length, *order;
GtkTreePath *path_a, *path_b;
GtkTreeIter parent;
node_b->next = a_next;
/* emit signal */
- order = g_new (gint, length);
+ order = g_new (int, length);
for (i = 0; i < length; i++)
if (i == a_count)
order[i] = b_count;
gboolean before)
{
GNode *parent, *node, *a, *b, *tmp, *tmp_a, *tmp_b;
- gint old_pos, new_pos, length, i, *order;
+ int old_pos, new_pos, length, i, *order;
GtkTreePath *path = NULL, *tmppath, *pos_path = NULL;
GtkTreeIter parent_iter, dst_a, dst_b;
- gint depth = 0;
+ int depth = 0;
gboolean handle_b = TRUE;
g_return_if_fail (GTK_IS_TREE_STORE (tree_store));
new_pos++;
}
- order = g_new (gint, length);
+ order = g_new (int, length);
if (new_pos > old_pos)
{
for (i = 0; i < length; i++)
}
/* Sorting */
-static gint
+static int
gtk_tree_store_compare_func (gconstpointer a,
gconstpointer b,
gpointer user_data)
GtkTreeIter iter_a;
GtkTreeIter iter_b;
- gint retval;
+ int retval;
if (priv->sort_column_id != -1)
{
GArray *sort_array;
GNode *node;
GNode *tmp_node;
- gint list_length;
- gint i;
- gint *new_order;
+ int list_length;
+ int i;
+ int *new_order;
GtkTreePath *path;
node = parent->children;
parent->children = g_array_index (sort_array, SortTuple, 0).node;
/* Let the world know about our new order */
- new_order = g_new (gint, list_length);
+ new_order = g_new (int, list_length);
for (i = 0; i < list_length; i++)
new_order[i] = g_array_index (sort_array, SortTuple, i).offset;
static void
gtk_tree_store_sort_iter_changed (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint column,
+ int column,
gboolean emit_signal)
{
GtkTreeStorePrivate *priv = tree_store->priv;
GNode *node;
GtkTreePath *tmp_path;
GtkTreeIter tmp_iter;
- gint cmp_a = 0;
- gint cmp_b = 0;
- gint i;
- gint old_location;
- gint new_location;
- gint *new_order;
- gint length;
+ int cmp_a = 0;
+ int cmp_b = 0;
+ int i;
+ int old_location;
+ int new_location;
+ int *new_order;
+ int length;
GtkTreeIterCompareFunc func;
gpointer data;
static gboolean
gtk_tree_store_get_sort_column_id (GtkTreeSortable *sortable,
- gint *sort_column_id,
+ int *sort_column_id,
GtkSortType *order)
{
GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
static void
gtk_tree_store_set_sort_column_id (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkSortType order)
{
GtkTreeStore *tree_store = (GtkTreeStore *) sortable;
static void
gtk_tree_store_set_sort_func (GtkTreeSortable *sortable,
- gint sort_column_id,
+ int sort_column_id,
GtkTreeIterCompareFunc func,
gpointer data,
GDestroyNotify destroy)
GDK_AVAILABLE_IN_ALL
GType gtk_tree_store_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-GtkTreeStore *gtk_tree_store_new (gint n_columns,
+GtkTreeStore *gtk_tree_store_new (int n_columns,
...);
GDK_AVAILABLE_IN_ALL
-GtkTreeStore *gtk_tree_store_newv (gint n_columns,
+GtkTreeStore *gtk_tree_store_newv (int n_columns,
GType *types);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_set_column_types (GtkTreeStore *tree_store,
- gint n_columns,
+ int n_columns,
GType *types);
/* NOTE: use gtk_tree_model_get to get values from a GtkTreeStore */
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_set_value (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_set (GtkTreeStore *tree_store,
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_set_valuesv (GtkTreeStore *tree_store,
GtkTreeIter *iter,
- gint *columns,
+ int *columns,
GValue *values,
- gint n_values);
+ int n_values);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_set_valist (GtkTreeStore *tree_store,
GtkTreeIter *iter,
void gtk_tree_store_insert (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_insert_before (GtkTreeStore *tree_store,
GtkTreeIter *iter,
void gtk_tree_store_insert_with_values (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint position,
+ int position,
...);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_insert_with_valuesv (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint position,
- gint *columns,
+ int position,
+ int *columns,
GValue *values,
- gint n_values);
+ int n_values);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_prepend (GtkTreeStore *tree_store,
GtkTreeIter *iter,
GtkTreeIter *iter,
GtkTreeIter *descendant);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_store_iter_depth (GtkTreeStore *tree_store,
+int gtk_tree_store_iter_depth (GtkTreeStore *tree_store,
GtkTreeIter *iter);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_clear (GtkTreeStore *tree_store);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_reorder (GtkTreeStore *tree_store,
GtkTreeIter *parent,
- gint *new_order);
+ int *new_order);
GDK_AVAILABLE_IN_ALL
void gtk_tree_store_swap (GtkTreeStore *tree_store,
GtkTreeIter *a,
typedef struct _GtkTreeViewColumnReorder GtkTreeViewColumnReorder;
struct _GtkTreeViewColumnReorder
{
- gint left_align;
- gint right_align;
+ int left_align;
+ int right_align;
GtkTreeViewColumn *left_column;
GtkTreeViewColumn *right_column;
};
/* Container info */
GList *children;
- gint width;
+ int width;
guint presize_handler_tick_cb;
/* Adjustments */
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
- gint min_display_width;
- gint min_display_height;
+ int min_display_width;
+ int min_display_height;
/* CSS nodes */
GtkCssNode *header_node;
/* Scroll position state keeping */
GtkTreeRowReference *top_row;
- gint top_row_dy;
+ int top_row_dy;
/* dy == y pos of top_row + top_row_dy */
/* we cache it for simplicity of the code */
- gint dy;
+ int dy;
guint validate_rows_timer;
guint scroll_sync_timer;
/* Indentation and expander layout */
GtkTreeViewColumn *expander_column;
- gint level_indentation;
+ int level_indentation;
/* Key navigation (focus), selection */
- gint cursor_offset;
+ int cursor_offset;
GtkTreeRowReference *anchor;
GtkTreeRBNode *cursor_node;
GtkTreeRBNode *button_pressed_node;
GtkTreeRBTree *button_pressed_tree;
- gint press_start_x;
- gint press_start_y;
+ int press_start_x;
+ int press_start_y;
- gint event_last_x;
- gint event_last_y;
+ int event_last_x;
+ int event_last_y;
GtkTreeRBNode *prelight_node;
GtkTreeRBTree *prelight_tree;
GtkTreeSelection *selection;
/* Header information */
- gint header_height;
- gint n_columns;
+ int header_height;
+ int n_columns;
GList *columns;
GtkTreeViewColumnDropFunc column_drop_func;
GList *column_drag_info;
GtkTreeViewColumnReorder *cur_reorder;
- gint prev_width_before_expander;
+ int prev_width_before_expander;
/* Scroll timeout (e.g. during dnd, rubber banding) */
guint scroll_timeout;
/* Interactive Header reordering */
GtkTreeViewColumn *drag_column;
- gint drag_column_x;
- gint drag_column_y;
+ int drag_column_x;
+ int drag_column_y;
/* Interactive Header Resizing */
- gint drag_pos;
- gint x_drag;
+ int drag_pos;
+ int x_drag;
/* Row drag-and-drop */
GtkTreeRowReference *drag_dest_row;
guint open_dest_timeout;
/* Rubber banding */
- gint rubber_band_status;
- gint rubber_band_x;
- gint rubber_band_y;
- gint rubber_band_extend;
- gint rubber_band_modify;
+ int rubber_band_status;
+ int rubber_band_x;
+ int rubber_band_y;
+ int rubber_band_extend;
+ int rubber_band_modify;
/* fixed height */
- gint fixed_height;
+ int fixed_height;
GtkTreeRBNode *rubber_band_start_node;
GtkTreeRBTree *rubber_band_start_tree;
gfloat scroll_to_col_align;
/* Interactive search */
- gint selected_iter;
- gint search_column;
+ int selected_iter;
+ int search_column;
GtkTreeViewSearchEqualFunc search_equal_func;
gpointer search_user_data;
GDestroyNotify search_destroy;
GtkGesture *column_drag_gesture; /* Column reordering, resizing */
/* Tooltip support */
- gint tooltip_column;
+ int tooltip_column;
int expander_size;
static void gtk_tree_view_focus_controller_focus_out (GtkEventController *focus,
GtkTreeView *tree_view);
-static gint gtk_tree_view_focus (GtkWidget *widget,
+static int gtk_tree_view_focus (GtkWidget *widget,
GtkDirectionType direction);
static gboolean gtk_tree_view_grab_focus (GtkWidget *widget);
static void gtk_tree_view_css_changed (GtkWidget *widget,
/* tree_model signals */
static gboolean gtk_tree_view_real_move_cursor (GtkTreeView *tree_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
static gboolean gtk_tree_view_real_select_all (GtkTreeView *tree_view);
static void gtk_tree_view_rows_reordered (GtkTreeModel *model,
GtkTreePath *parent,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer data);
/* Incremental reflow */
static void install_scroll_sync_handler (GtkTreeView *tree_view);
static void gtk_tree_view_set_top_row (GtkTreeView *tree_view,
GtkTreePath *path,
- gint offset);
+ int offset);
static void gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view);
static void gtk_tree_view_top_row_to_dy (GtkTreeView *tree_view);
static void invalidate_empty_focus (GtkTreeView *tree_view);
guint modmask,
gboolean add_shifted_binding,
GtkMovementStep step,
- gint count);
-static gint gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
+ int count);
+static int gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
GtkTreeRBTree *tree);
static void gtk_tree_view_snapshot_arrow (GtkTreeView *tree_view,
GtkSnapshot *snapshot,
GtkTreeRBNode *node);
static void gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
- gint *x1,
- gint *x2);
+ int *x1,
+ int *x2);
static void gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
GtkTreeView *tree_view);
static void gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeIter *iter,
- gint depth,
+ int depth,
gboolean recurse);
static void gtk_tree_view_clamp_node_visible (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
static gboolean gtk_tree_view_maybe_begin_dragging_row (GtkTreeView *tree_view);
static void gtk_tree_view_focus_to_cursor (GtkTreeView *tree_view);
static void gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
- gint count);
+ int count);
static void gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
- gint count);
+ int count);
static void gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
- gint count);
+ int count);
static void gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
- gint count);
+ int count);
static gboolean gtk_tree_view_real_collapse_row (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeRBTree *tree,
int x,
int y);
-static inline gint gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
+static inline int gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view);
-static inline gint gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
+static inline int gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeRBNode *node);
-static inline gint gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
+static inline int gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
GtkTreeRBNode *node);
-static inline gint gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
+static inline int gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeRBNode *node);
-static inline gint gtk_tree_view_get_row_height (GtkTreeView *tree_view,
+static inline int gtk_tree_view_get_row_height (GtkTreeView *tree_view,
GtkTreeRBNode *node);
static TreeViewDragInfo* get_info (GtkTreeView *tree_view);
GtkTreeView *tree_view,
gboolean up);
static gboolean gtk_tree_view_search_equal_func (GtkTreeModel *model,
- gint column,
+ int column,
const gchar *key,
GtkTreeIter *iter,
gpointer search_data);
GtkTreeSelection *selection,
GtkTreeIter *iter,
const gchar *text,
- gint *count,
- gint n);
+ int *count,
+ int n);
static void gtk_tree_view_search_init (GtkWidget *entry,
GtkTreeView *tree_view);
static void gtk_tree_view_put (GtkTreeView *tree_view,
static gboolean gtk_tree_view_start_interactive_search (GtkTreeView *tree_view);
static GtkTreeViewColumn *gtk_tree_view_get_drop_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column,
- gint drop_position);
+ int drop_position);
/* GtkBuildable */
static void gtk_tree_view_buildable_add_child (GtkBuildable *tree_view,
/* Gestures */
static void gtk_tree_view_column_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view);
static void gtk_tree_view_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view);
static void gtk_tree_view_click_gesture_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view);
}
}
-static gint
+static int
gtk_tree_view_get_height (GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
{
GList *list;
GtkTreeViewColumn *column;
- gint width = 0;
+ int width = 0;
/* we validate some rows initially just to make sure we have some size.
* In practice, with a lot of static lists, this should get a good width.
const int x_offset = - gtk_adjustment_get_value (priv->hadjustment);
GList *list, *first_column, *last_column;
GtkTreeViewColumn *column;
- gint widget_width, width = 0;
- gint extra, extra_per_column;
- gint full_requested_width = 0;
- gint number_of_expand_columns = 0;
+ int widget_width, width = 0;
+ int extra, extra_per_column;
+ int full_requested_width = 0;
+ int number_of_expand_columns = 0;
gboolean rtl;
for (last_column = g_list_last (priv->columns);
list != last_column->next;
list = list->next)
{
- gint column_width;
+ int column_width;
column = list->data;
column_width = _gtk_tree_view_column_request_width (column);
* width that makes the expander move vertically. Always updating
* prelight status causes trouble with hover selections.
*/
- gint width_before_expander;
+ int width_before_expander;
width_before_expander = gtk_tree_view_calculate_width_before_expander (tree_view);
GdkEventSequence *sequence;
GdkModifierType modifiers;
GdkEvent *event;
- gint new_y, y_offset;
- gint bin_x, bin_y;
+ int new_y, y_offset;
+ int bin_x, bin_y;
GtkTreePath *path;
GtkTreeRBNode *node;
GtkTreeRBTree *tree;
- gint depth;
+ int depth;
guint button;
GList *list;
gboolean rtl;
if (gtk_tree_view_draw_expanders (tree_view))
{
- gint expander_size = gtk_tree_view_get_expander_size (tree_view);
+ int expander_size = gtk_tree_view_get_expander_size (tree_view);
if (!rtl)
cell_area.x += depth * expander_size;
cell_area.width -= depth * expander_size;
GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint bin_x, bin_y;
+ int bin_x, bin_y;
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
static void
gtk_tree_view_column_click_gesture_pressed (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view)
GtkTreeViewColumn *column;
gboolean rtl;
GList *list;
- gint i;
+ int i;
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
for (i = 0, list = priv->columns; list; list = list->next, i++)
{
gpointer drag_data;
- gint column_width;
+ int column_width;
column = list->data;
static void
gtk_tree_view_click_gesture_released (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkTreeView *tree_view)
GtkTreeRBTree *tree,
GtkTreeRBNode *node,
/* these are in bin window coords */
- gint x,
- gint y)
+ int x,
+ int y)
{
GdkRectangle arrow;
- gint x2;
+ int x2;
if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return FALSE;
GtkTreeRBTree *tree,
GtkTreeRBNode *node,
/* these are in bin_window coords */
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *tree,
GtkTreeRBNode *node,
/* these are in bin_window coords */
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkSelectionMode mode = gtk_tree_selection_get_mode (priv->selection);
static void
update_prelight (GtkTreeView *tree_view,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
int new_y;
gdouble y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint new_width;
+ int new_width;
GtkTreeViewColumn *column;
column = gtk_tree_view_get_column (tree_view, priv->drag_pos);
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GdkRectangle visible_rect;
- gint y;
- gint offset;
+ int y;
+ int offset;
if (gtk_gesture_is_recognized (priv->drag_gesture))
{
GdkEventSequence *sequence;
GdkRectangle visible_rect;
gdouble x;
- gint offset;
+ int offset;
sequence = gtk_gesture_single_get_current_sequence
(GTK_GESTURE_SINGLE (priv->column_drag_gesture));
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeViewColumn *column = priv->drag_column;
GtkWidget *button;
- gint width, button_width;
+ int width, button_width;
button = gtk_tree_view_column_get_button (column);
x += gtk_adjustment_get_value (priv->hadjustment);
GtkTreeRBTree *start_tree, *end_tree;
GtkTreeRBNode *start_node, *end_node;
gdouble start_y, offset_y;
- gint bin_y;
+ int bin_y;
if (!gtk_gesture_is_active (priv->drag_gesture))
return;
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
gdouble start_x, start_y, offset_x, offset_y, x, y;
- gint bin_x, bin_y;
+ int bin_x, bin_y;
if (!gtk_gesture_is_recognized (priv->drag_gesture))
return;
gdouble start_x, start_y, offset_x, offset_y;
GdkRectangle rect;
GtkStyleContext *context;
- gint bin_x, bin_y;
+ int bin_x, bin_y;
if (!gtk_gesture_is_recognized (priv->drag_gesture))
return;
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
- gint new_y;
+ int new_y;
GList *list;
gboolean cursor_set = FALSE;
if (priv->tree)
{
- gint bin_x, bin_y;
+ int bin_x, bin_y;
/* If we are currently pressing down a button, we don't want to prelight anything else. */
if (gtk_gesture_is_active (priv->drag_gesture) ||
GtkTreeRBNode *drag_highlight = NULL;
GtkTreeRBTree *drag_highlight_tree = NULL;
GtkTreeIter iter;
- gint new_y;
- gint y_offset, cell_offset;
- gint max_height;
- gint depth;
+ int new_y;
+ int y_offset, cell_offset;
+ int max_height;
+ int depth;
GdkRectangle background_area;
GdkRectangle cell_area;
GdkRectangle clip;
guint flags;
- gint bin_window_width;
- gint bin_window_height;
+ int bin_window_width;
+ int bin_window_height;
GtkTreePath *drag_dest_path;
GList *first_column, *last_column;
gboolean has_can_focus_cell;
gboolean rtl;
- gint n_visible_columns;
- gint expander_size;
+ int n_visible_columns;
+ int expander_size;
gboolean draw_vgrid_lines, draw_hgrid_lines;
GtkStyleContext *context;
gboolean parity;
do
{
gboolean is_separator = FALSE;
- gint n_col = 0;
+ int n_col = 0;
parity = !parity;
is_separator = row_is_separator (tree_view, &iter, NULL);
{
GtkTreeViewColumn *column = list->data;
GtkStateFlags state = 0;
- gint width;
+ int width;
gboolean draw_focus;
if (!gtk_tree_view_column_get_visible (column))
if (gtk_tree_view_is_expander_column (tree_view, column) &&
priv->tree_lines_enabled)
{
- gint x = background_area.x;
- gint mult = rtl ? -1 : 1;
- gint y0 = background_area.y;
- gint y1 = background_area.y + background_area.height/2;
- gint y2 = background_area.y + background_area.height;
+ int x = background_area.x;
+ int mult = rtl ? -1 : 1;
+ int y0 = background_area.y;
+ int y1 = background_area.y + background_area.height/2;
+ int y2 = background_area.y + background_area.height;
if (rtl)
x += background_area.width - 1;
priv->draw_keyfocus &&
gtk_widget_has_visible_focus (widget))
{
- gint tmp_y, tmp_height;
+ int tmp_y, tmp_height;
GtkStateFlags focus_rect_state = 0;
gtk_style_context_save (context);
GtkWidget *button;
GtkStyleContext *context;
GList *list;
- gint width, height;
+ int width, height;
context = gtk_widget_get_style_context (widget);
width = gtk_widget_get_width (widget);
gtk_snapshot_save (snapshot);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (
- - (gint) gtk_adjustment_get_value (priv->hadjustment),
+ - (int) gtk_adjustment_get_value (priv->hadjustment),
gtk_tree_view_get_effective_header_height (tree_view)));
gtk_tree_view_bin_snapshot (widget, snapshot);
gtk_snapshot_restore (snapshot);
static GtkTreeViewColumn *
gtk_tree_view_get_drop_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column,
- gint drop_position)
+ int drop_position)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeViewColumn *left_column = NULL;
|| keyval == GDK_KEY_Right || keyval == GDK_KEY_KP_Right))
{
GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN (focus_column->data);
- gint column_width;
+ int column_width;
if (!gtk_tree_view_column_get_resizable (column))
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
- gint new_y;
+ int new_y;
if (priv->tree == NULL)
return;
/* Incremental Reflow
*/
-static gint
+static int
get_separator_height (GtkTreeView *tree_view)
{
GtkStyleContext *context;
GtkCssStyle *style;
gdouble d;
- gint min_size;
+ int min_size;
context = gtk_widget_get_style_context (GTK_WIDGET (tree_view));
gtk_style_context_save (context);
GtkTreeViewColumn *column;
GtkStyleContext *context;
GList *list, *first_column, *last_column;
- gint height = 0;
- gint depth = gtk_tree_path_get_depth (path);
+ int height = 0;
+ int depth = gtk_tree_path_get_depth (path);
gboolean retval = FALSE;
gboolean is_separator = FALSE;
gboolean draw_vgrid_lines, draw_hgrid_lines;
- gint expander_size;
+ int expander_size;
int separator_height;
/* double check the row needs validating */
for (list = priv->columns; list; list = list->next)
{
- gint padding = 0;
- gint original_width;
- gint new_width;
- gint row_height;
+ int padding = 0;
+ int original_width;
+ int new_width;
+ int row_height;
column = list->data;
GtkTreeRBNode *node = NULL;
gboolean need_redraw = FALSE;
gboolean size_changed = FALSE;
- gint total_height;
- gint area_above = 0;
- gint area_below = 0;
+ int total_height;
+ int area_above = 0;
+ int area_below = 0;
if (priv->tree == NULL)
return;
if (priv->scroll_to_use_align)
{
- gint height = gtk_tree_view_get_row_height (tree_view, node);
+ int height = gtk_tree_view_get_row_height (tree_view, node);
area_above = (total_height - height) *
priv->scroll_to_row_align;
area_below = total_height - area_above - height;
* 1) row not visible
* 2) row visible
*/
- gint dy;
- gint height = gtk_tree_view_get_row_height (tree_view, node);
+ int dy;
+ int height = gtk_tree_view_get_row_height (tree_view, node);
dy = gtk_tree_rbtree_node_find_offset (tree, node);
*/
if (path == NULL)
{
- gint offset;
+ int offset;
offset = gtk_tree_rbtree_find_offset (priv->tree,
TREE_WINDOW_Y_TO_RBTREE_Y (priv, 0),
GtkTreeRBTree *tree = NULL;
GtkTreeRBNode *node = NULL;
gboolean validated_area = FALSE;
- gint retval = TRUE;
+ int retval = TRUE;
GtkTreePath *path = NULL;
GtkTreeIter iter;
GTimer *timer;
- gint i = 0;
+ int i = 0;
- gint y = -1;
- gint prev_height = -1;
+ int y = -1;
+ int prev_height = -1;
gboolean fixed_height = TRUE;
g_assert (tree_view);
if (changed)
{
- gint offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
+ int offset = gtk_tree_view_get_row_y_offset (tree_view, tree, node);
if (y == -1 || y > offset)
y = offset;
if (!priv->fixed_height_check)
{
- gint height;
+ int height;
height = gtk_tree_view_get_row_height (tree_view, node);
if (prev_height < 0)
if (validated_area)
{
GtkRequisition requisition;
- gint dummy;
+ int dummy;
/* We temporarily guess a size, under the assumption that it will be the
* same when we get our next size_allocate. If we don't do this, we'll be
static void
gtk_tree_view_set_top_row (GtkTreeView *tree_view,
GtkTreePath *path,
- gint offset)
+ int offset)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
gtk_tree_view_dy_to_top_row (GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint offset;
+ int offset;
GtkTreePath *path;
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
}
-static gint
+static int
open_row_timeout (gpointer data)
{
GtkTreeView *tree_view = data;
set_destination_row (GtkTreeView *tree_view,
GtkDropTargetAsync *dest,
/* coordinates relative to the widget */
- gint x,
- gint y,
+ int x,
+ int y,
GdkDragAction *suggested_action,
GType *target)
{
&path,
&pos))
{
- gint n_children;
+ int n_children;
GtkTreeModel *model;
remove_open_timeout (tree_view);
gdouble start_x, start_y, offset_x, offset_y;
TreeViewDragInfo *di;
GtkTreePath *path = NULL;
- gint button;
+ int button;
GtkTreeModel *model;
gboolean retval = FALSE;
- gint bin_x, bin_y;
+ int bin_x, bin_y;
GdkSurface *surface;
GdkDevice *device;
GdkContentProvider *content;
return (*path != NULL);
}
-static gint
+static int
gtk_tree_view_focus (GtkWidget *widget,
GtkDirectionType direction)
{
static gboolean
gtk_tree_view_real_move_cursor (GtkTreeView *tree_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify)
{
{
GtkTreeView *tree_view = (GtkTreeView *) data;
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint *indices;
+ int *indices;
GtkTreeRBTree *tree;
GtkTreeRBNode *tmpnode = NULL;
- gint depth;
- gint i = 0;
- gint height;
+ int depth;
+ int i = 0;
+ int height;
gboolean free_path = FALSE;
g_return_if_fail (path != NULL || iter != NULL);
GtkTreeRBNode *node,
gpointer data)
{
- gint *value = (gint *)data;
+ int *value = (int *)data;
*value |= GTK_TREE_RBNODE_FLAG_SET (node, GTK_TREE_RBNODE_IS_SELECTED);
gtk_tree_view_rows_reordered (GtkTreeModel *model,
GtkTreePath *parent,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer data)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (data);
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
- gint len;
+ int len;
len = gtk_tree_model_iter_n_children (model, iter);
gtk_tree_view_get_background_xrange (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeViewColumn *column,
- gint *x1,
- gint *x2)
+ int *x1,
+ int *x2)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeViewColumn *tmp_column = NULL;
- gint total_width;
+ int total_width;
GList *list;
gboolean rtl;
static void
gtk_tree_view_get_arrow_xrange (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
- gint *x1,
- gint *x2)
+ int *x1,
+ int *x2)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint x_offset = 0;
+ int x_offset = 0;
GList *list;
GtkTreeViewColumn *tmp_column = NULL;
- gint total_width;
- gint expander_size, expander_render_size;
+ int total_width;
+ int expander_size, expander_render_size;
gboolean rtl;
rtl = (_gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
gtk_tree_view_build_tree (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeIter *iter,
- gint depth,
+ int depth,
gboolean recurse)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBNode *node)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint node_dy, height;
+ int node_dy, height;
GtkTreePath *path = NULL;
if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkAllocation allocation;
- gint x, width;
+ int x, width;
if (column == NULL)
return;
GtkTreePath *path;
GtkTreeRBTree *tmp_tree;
GtkTreeRBNode *tmp_node, *last;
- gint count;
+ int count;
path = gtk_tree_path_new ();
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBNode *tmpnode = NULL;
GtkTreeRBTree *tmptree = priv->tree;
- gint *indices = gtk_tree_path_get_indices (path);
- gint depth = gtk_tree_path_get_depth (path);
- gint i = 0;
+ int *indices = gtk_tree_path_get_indices (path);
+ int depth = gtk_tree_path_get_depth (path);
+ int i = 0;
*node = NULL;
*tree = NULL;
guint modmask,
gboolean add_shifted_binding,
GtkMovementStep step,
- gint count)
+ int count)
{
gtk_widget_class_add_binding_signal (widget_class,
keyval, modmask,
"(iibb)", step, count, TRUE, TRUE);
}
-static gint
+static int
gtk_tree_view_unref_tree_helper (GtkTreeModel *model,
GtkTreeIter *iter,
GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint retval = FALSE;
+ int retval = FALSE;
do
{
g_return_val_if_fail (node != NULL, FALSE);
return retval;
}
-static gint
+static int
gtk_tree_view_unref_and_check_selection_tree (GtkTreeView *tree_view,
GtkTreeRBTree *tree)
{
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeRBNode *node;
- gint retval;
+ int retval;
if (!tree)
return FALSE;
GtkTreeViewColumnReorder *reorder;
gboolean rtl;
GList *tmp_list;
- gint left;
+ int left;
/* We want to precalculate the motion list such that we know what column slots
* are available.
GTK_EVENT_SEQUENCE_CLAIMED);
}
-static inline gint
+static inline int
gtk_tree_view_get_effective_header_height (GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkStateFlags state = 0;
GtkStyleContext *context;
GtkWidget *widget;
- gint x_offset = 0;
- gint x2;
+ int x_offset = 0;
+ int x2;
GtkCellRendererState flags = 0;
widget = GTK_WIDGET (tree_view);
static void
gtk_tree_view_move_cursor_up_down (GtkTreeView *tree_view,
- gint count)
+ int count)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint selection_count;
+ int selection_count;
GtkTreeRBTree *new_cursor_tree = NULL;
GtkTreeRBNode *new_cursor_node = NULL;
GtkTreePath *cursor_path = NULL;
static void
gtk_tree_view_move_cursor_page_up_down (GtkTreeView *tree_view,
- gint count)
+ int count)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreePath *old_cursor_path = NULL;
GtkTreeRBNode *start_cursor_node = NULL;
GtkTreeRBTree *cursor_tree;
GtkTreeRBNode *cursor_node;
- gint y;
- gint window_y;
+ int y;
+ int window_y;
if (!gtk_widget_has_focus (GTK_WIDGET (tree_view)))
return;
window_y = RBTREE_Y_TO_TREE_WINDOW_Y (priv, y);
y += priv->cursor_offset;
y += count * (int)gtk_adjustment_get_page_increment (priv->vadjustment);
- y = CLAMP (y, (gint)gtk_adjustment_get_lower (priv->vadjustment), (gint)gtk_adjustment_get_upper (priv->vadjustment));
+ y = CLAMP (y, (int)gtk_adjustment_get_lower (priv->vadjustment), (int)gtk_adjustment_get_upper (priv->vadjustment));
if (y >= gtk_tree_view_get_height (tree_view))
y = gtk_tree_view_get_height (tree_view) - 1;
static void
gtk_tree_view_move_cursor_left_right (GtkTreeView *tree_view,
- gint count)
+ int count)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreePath *cursor_path = NULL;
static void
gtk_tree_view_move_cursor_start_end (GtkTreeView *tree_view,
- gint count)
+ int count)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *cursor_tree;
if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
GtkAllocation allocation;
- gint dy;
+ int dy;
gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
dy = priv->dy - (int) gtk_adjustment_get_value (priv->vadjustment);
if (priv->model)
{
- gint i;
+ int i;
GtkTreePath *path;
GtkTreeIter iter;
GtkTreeModelFlags flags;
*
* Returns: The number of columns in @tree_view after appending.
**/
-gint
+int
gtk_tree_view_append_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column)
{
*
* Returns: The number of columns in @tree_view after removing.
**/
-gint
+int
gtk_tree_view_remove_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column)
{
*
* Returns: The number of columns in @tree_view after insertion.
**/
-gint
+int
gtk_tree_view_insert_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column,
- gint position)
+ int position)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
*
* Returns: The number of columns in @tree_view after insertion.
**/
-gint
+int
gtk_tree_view_insert_column_with_attributes (GtkTreeView *tree_view,
- gint position,
+ int position,
const gchar *title,
GtkCellRenderer *cell,
...)
GtkTreeViewColumn *column;
gchar *attribute;
va_list args;
- gint column_id;
+ int column_id;
g_return_val_if_fail (GTK_IS_TREE_VIEW (tree_view), -1);
while (attribute != NULL)
{
- column_id = va_arg (args, gint);
+ column_id = va_arg (args, int);
gtk_tree_view_column_add_attribute (column, cell, attribute, column_id);
attribute = va_arg (args, gchar *);
}
*
* Returns: number of columns in the tree view post-insert
**/
-gint
+int
gtk_tree_view_insert_column_with_data_func (GtkTreeView *tree_view,
- gint position,
+ int position,
const gchar *title,
GtkCellRenderer *cell,
GtkTreeCellDataFunc func,
**/
GtkTreeViewColumn *
gtk_tree_view_get_column (GtkTreeView *tree_view,
- gint n)
+ int n)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
**/
void
gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
- gint tree_x,
- gint tree_y)
+ int tree_x,
+ int tree_y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkAdjustment *hadj;
{
GdkRectangle cell_rect;
GdkRectangle vis_rect;
- gint dest_x, dest_y;
+ int dest_x, dest_y;
gtk_tree_view_get_background_area (tree_view, path, column, &cell_rect);
gtk_tree_view_get_visible_rect (tree_view, &vis_rect);
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
GtkTreePath *path;
- gint *indices;
+ int *indices;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
gtk_tree_view_expand_to_path (GtkTreeView *tree_view,
GtkTreePath *path)
{
- gint i, depth;
- gint *indices;
+ int i, depth;
+ int *indices;
GtkTreePath *tmp;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
**/
gboolean
gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path,
GtkTreeViewColumn **column,
- gint *cell_x,
- gint *cell_y)
+ int *cell_x,
+ int *cell_y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
- gint y_offset;
+ int y_offset;
g_return_val_if_fail (tree_view != NULL, FALSE);
GtkTreeViewColumn *tmp_column;
GtkTreeViewColumn *last_column = NULL;
GList *list;
- gint remaining_x = x;
+ int remaining_x = x;
gboolean found = FALSE;
gboolean rtl;
- gint width;
+ int width;
rtl = (_gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
for (list = (rtl ? g_list_last (priv->columns) : g_list_first (priv->columns));
}
-static inline gint
+static inline int
gtk_tree_view_get_cell_area_height (GtkTreeView *tree_view,
GtkTreeRBNode *node)
{
return height;
}
-static inline gint
+static inline int
gtk_tree_view_get_cell_area_y_offset (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeRBNode *node)
if (column &&
gtk_tree_view_is_expander_column (tree_view, column))
{
- gint depth = gtk_tree_path_get_depth (path);
+ int depth = gtk_tree_path_get_depth (path);
gboolean rtl;
rtl = _gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL;
}
}
-static inline gint
+static inline int
gtk_tree_view_get_row_height (GtkTreeView *tree_view,
GtkTreeRBNode *node)
{
return height;
}
-static inline gint
+static inline int
gtk_tree_view_get_row_y_offset (GtkTreeView *tree_view,
GtkTreeRBTree *tree,
GtkTreeRBNode *node)
if (column)
{
- gint x2 = 0;
+ int x2 = 0;
gtk_tree_view_get_background_xrange (tree_view, tree, column, &rect->x, &x2);
rect->width = x2 - rect->x;
**/
void
gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
- gint wx,
- gint wy,
- gint *tx,
- gint *ty)
+ int wx,
+ int wy,
+ int *tx,
+ int *ty)
{
- gint x, y;
+ int x, y;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
**/
void
gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
- gint tx,
- gint ty,
- gint *wx,
- gint *wy)
+ int tx,
+ int ty,
+ int *wx,
+ int *wy)
{
- gint x, y;
+ int x, y;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
**/
void
gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
- gint wx,
- gint wy,
- gint *bx,
- gint *by)
+ int wx,
+ int wy,
+ int *bx,
+ int *by)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
**/
void
gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
- gint bx,
- gint by,
- gint *wx,
- gint *wy)
+ int bx,
+ int by,
+ int *wx,
+ int *wy)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
**/
void
gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
- gint tx,
- gint ty,
- gint *bx,
- gint *by)
+ int tx,
+ int ty,
+ int *bx,
+ int *by)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
**/
void
gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
- gint bx,
- gint by,
- gint *tx,
- gint *ty)
+ int bx,
+ int by,
+ int *tx,
+ int *ty)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
if (end_path)
{
- gint y;
+ int y;
if (gtk_tree_view_get_height (tree_view) < gtk_adjustment_get_page_size (priv->vadjustment))
y = gtk_tree_view_get_height (tree_view) - 1;
*/
gboolean
gtk_tree_view_is_blank_at_pos (GtkTreeView *tree_view,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path,
GtkTreeViewColumn **column,
- gint *cell_x,
- gint *cell_y)
+ int *cell_x,
+ int *cell_y)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
GtkTreeRBTree *tree;
&& gtk_tree_path_get_depth (path) == 1
&& gtk_tree_path_get_indices (path)[0] == 0)
{
- gint n_children;
+ int n_children;
n_children = gtk_tree_model_iter_n_children (priv->model,
NULL);
**/
gboolean
gtk_tree_view_get_dest_row_at_pos (GtkTreeView *tree_view,
- gint drag_x,
- gint drag_y,
+ int drag_x,
+ int drag_y,
GtkTreePath **path,
GtkTreeViewDropPosition *pos)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint cell_y;
- gint bin_x, bin_y;
+ int cell_y;
+ int bin_x, bin_y;
gdouble offset_into_row;
gdouble fourth;
GdkRectangle cell;
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
GtkStyleContext *context;
- gint cell_offset;
+ int cell_offset;
GList *list;
GdkRectangle background_area;
GtkWidget *widget;
GtkSnapshot *snapshot;
GdkPaintable *paintable;
- gint depth;
+ int depth;
/* start drawing inside the black outline */
- gint x = 1, y = 1;
- gint bin_window_width;
+ int x = 1, y = 1;
+ int bin_window_width;
gboolean is_separator = FALSE;
gboolean rtl;
*
* Returns: the column the interactive search code searches in.
*/
-gint
+int
gtk_tree_view_get_search_column (GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
*/
void
gtk_tree_view_set_search_column (GtkTreeView *tree_view,
- gint column)
+ int column)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
gboolean ret;
- gint len;
- gint count = 0;
+ int len;
+ int count = 0;
const gchar *text;
GtkTreeIter iter;
GtkTreeModel *model;
static gboolean
gtk_tree_view_search_equal_func (GtkTreeModel *model,
- gint column,
+ int column,
const gchar *key,
GtkTreeIter *iter,
gpointer search_data)
GtkTreeSelection *selection,
GtkTreeIter *iter,
const gchar *text,
- gint *count,
- gint n)
+ int *count,
+ int n)
{
GtkTreeRBTree *tree = NULL;
GtkTreeRBNode *node = NULL;
GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
- gint ret;
- gint count = 0;
+ int ret;
+ int count = 0;
const gchar *text;
GtkTreeIter iter;
GtkTreeModel *model;
GdkRectangle cell_area;
GtkTreeViewColumn *focus_column;
guint flags = 0; /* can be 0, as the flags are primarily for rendering */
- gint retval = FALSE;
+ int retval = FALSE;
GtkTreeRBTree *cursor_tree;
GtkTreeRBNode *cursor_node;
*/
void
gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
- gint indentation)
+ int indentation)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
* Returns: the amount of extra indentation for child levels in
* @tree_view. A return value of 0 means that this feature is disabled.
*/
-gint
+int
gtk_tree_view_get_level_indentation (GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
if (column && cell)
{
GdkRectangle tmp;
- gint start, width;
+ int start, width;
/* We always pass in path here, whether it is NULL or not.
* For cells in expander columns path must be specified so that
*/
gboolean
gtk_tree_view_get_tooltip_context (GtkTreeView *tree_view,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
gboolean keyboard_tip,
GtkTreeModel **model,
GtkTreePath **path,
static gboolean
gtk_tree_view_set_tooltip_query_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
*/
void
gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
- gint column)
+ int column)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
* Returns: the index of the tooltip column that is currently being
* used, or -1 if this is disabled.
*/
-gint
+int
gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view)
{
GtkTreeViewPrivate *priv = gtk_tree_view_get_instance_private (tree_view);
* Returns: %FALSE if the row matches, %TRUE otherwise.
*/
typedef gboolean (*GtkTreeViewSearchEqualFunc) (GtkTreeModel *model,
- gint column,
+ int column,
const gchar *key,
GtkTreeIter *iter,
gpointer search_data);
/* Key Binding signals */
gboolean (* move_cursor) (GtkTreeView *tree_view,
GtkMovementStep step,
- gint count,
+ int count,
gboolean extend,
gboolean modify);
gboolean (* select_all) (GtkTreeView *tree_view);
/* Column functions */
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_append_column (GtkTreeView *tree_view,
+int gtk_tree_view_append_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_remove_column (GtkTreeView *tree_view,
+int gtk_tree_view_remove_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_insert_column (GtkTreeView *tree_view,
+int gtk_tree_view_insert_column (GtkTreeView *tree_view,
GtkTreeViewColumn *column,
- gint position);
+ int position);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_insert_column_with_attributes (GtkTreeView *tree_view,
- gint position,
+int gtk_tree_view_insert_column_with_attributes (GtkTreeView *tree_view,
+ int position,
const gchar *title,
GtkCellRenderer *cell,
...) G_GNUC_NULL_TERMINATED;
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_insert_column_with_data_func (GtkTreeView *tree_view,
- gint position,
+int gtk_tree_view_insert_column_with_data_func (GtkTreeView *tree_view,
+ int position,
const gchar *title,
GtkCellRenderer *cell,
GtkTreeCellDataFunc func,
guint gtk_tree_view_get_n_columns (GtkTreeView *tree_view);
GDK_AVAILABLE_IN_ALL
GtkTreeViewColumn *gtk_tree_view_get_column (GtkTreeView *tree_view,
- gint n);
+ int n);
GDK_AVAILABLE_IN_ALL
GList *gtk_tree_view_get_columns (GtkTreeView *tree_view);
GDK_AVAILABLE_IN_ALL
/* Actions */
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_scroll_to_point (GtkTreeView *tree_view,
- gint tree_x,
- gint tree_y);
+ int tree_x,
+ int tree_y);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_scroll_to_cell (GtkTreeView *tree_view,
GtkTreePath *path,
/* Layout information */
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path,
GtkTreeViewColumn **column,
- gint *cell_x,
- gint *cell_y);
+ int *cell_x,
+ int *cell_y);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_get_cell_area (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreePath **end_path);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_view_is_blank_at_pos (GtkTreeView *tree_view,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path,
GtkTreeViewColumn **column,
- gint *cell_x,
- gint *cell_y);
+ int *cell_x,
+ int *cell_y);
/* Drag-and-Drop support */
GDK_AVAILABLE_IN_ALL
GtkTreeViewDropPosition *pos);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_view_get_dest_row_at_pos (GtkTreeView *tree_view,
- gint drag_x,
- gint drag_y,
+ int drag_x,
+ int drag_y,
GtkTreePath **path,
GtkTreeViewDropPosition *pos);
GDK_AVAILABLE_IN_ALL
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_view_get_enable_search (GtkTreeView *tree_view);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_get_search_column (GtkTreeView *tree_view);
+int gtk_tree_view_get_search_column (GtkTreeView *tree_view);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_set_search_column (GtkTreeView *tree_view,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
GtkTreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func (GtkTreeView *tree_view);
GDK_AVAILABLE_IN_ALL
/* Convert between the different coordinate systems */
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_convert_widget_to_tree_coords (GtkTreeView *tree_view,
- gint wx,
- gint wy,
- gint *tx,
- gint *ty);
+ int wx,
+ int wy,
+ int *tx,
+ int *ty);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_convert_tree_to_widget_coords (GtkTreeView *tree_view,
- gint tx,
- gint ty,
- gint *wx,
- gint *wy);
+ int tx,
+ int ty,
+ int *wx,
+ int *wy);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_convert_widget_to_bin_window_coords (GtkTreeView *tree_view,
- gint wx,
- gint wy,
- gint *bx,
- gint *by);
+ int wx,
+ int wy,
+ int *bx,
+ int *by);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_convert_bin_window_to_widget_coords (GtkTreeView *tree_view,
- gint bx,
- gint by,
- gint *wx,
- gint *wy);
+ int bx,
+ int by,
+ int *wx,
+ int *wy);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_convert_tree_to_bin_window_coords (GtkTreeView *tree_view,
- gint tx,
- gint ty,
- gint *bx,
- gint *by);
+ int tx,
+ int ty,
+ int *bx,
+ int *by);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_convert_bin_window_to_tree_coords (GtkTreeView *tree_view,
- gint bx,
- gint by,
- gint *tx,
- gint *ty);
+ int bx,
+ int by,
+ int *tx,
+ int *ty);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
gboolean gtk_tree_view_get_show_expanders (GtkTreeView *tree_view);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
- gint indentation);
+ int indentation);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_get_level_indentation (GtkTreeView *tree_view);
+int gtk_tree_view_get_level_indentation (GtkTreeView *tree_view);
/* Convenience functions for setting tooltips */
GDK_AVAILABLE_IN_ALL
GtkCellRenderer *cell);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_view_get_tooltip_context(GtkTreeView *tree_view,
- gint *x,
- gint *y,
+ int *x,
+ int *y,
gboolean keyboard_tip,
GtkTreeModel **model,
GtkTreePath **path,
GtkTreeIter *iter);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_set_tooltip_column (GtkTreeView *tree_view,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view);
+int gtk_tree_view_get_tooltip_column (GtkTreeView *tree_view);
G_END_DECLS
/* Sizing fields */
/* see gtk+/doc/tree-column-sizing.txt for more information on them */
GtkTreeViewColumnSizing column_type;
- gint padding;
- gint x_offset;
- gint width;
- gint fixed_width;
- gint min_width;
- gint max_width;
+ int padding;
+ int x_offset;
+ int width;
+ int fixed_width;
+ int min_width;
+ int max_width;
/* dragging columns */
- gint drag_x;
- gint drag_y;
+ int drag_x;
+ int drag_y;
gchar *title;
/* Sorting */
gulong sort_clicked_signal;
gulong sort_column_changed_signal;
- gint sort_column_id;
+ int sort_column_id;
GtkSortType sort_order;
/* Cell area */
gtk_tree_view_column_update_button (GtkTreeViewColumn *tree_column)
{
GtkTreeViewColumnPrivate *priv = tree_column->priv;
- gint sort_column_id = -1;
+ int sort_column_id = -1;
GtkWidget *hbox;
GtkWidget *frame;
GtkWidget *arrow;
GtkTreeViewColumn *column)
{
GtkTreeViewColumnPrivate *priv = column->priv;
- gint sort_column_id;
+ int sort_column_id;
GtkSortType order;
if (gtk_tree_sortable_get_sort_column_id (sortable,
GtkTreeViewColumnPrivate *priv = tree_column->priv;
GtkTreeModel *model;
GtkTreeSortable *sortable;
- gint sort_column_id;
+ int sort_column_id;
GtkSortType order;
gboolean has_sort_column;
gboolean has_default_sort_func;
if (GTK_IS_TREE_SORTABLE (model) &&
priv->sort_column_id != -1)
{
- gint real_sort_column_id;
+ int real_sort_column_id;
GtkSortType real_order;
if (priv->sort_column_changed_signal == 0)
_gtk_tree_view_column_get_cell_at_pos (GtkTreeViewColumn *column,
GdkRectangle *cell_area,
GdkRectangle *background_area,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkCellRenderer *match = NULL;
GtkTreeViewColumnPrivate *priv = column->priv;
_gtk_tree_view_column_is_blank_at_pos (GtkTreeViewColumn *column,
GdkRectangle *cell_area,
GdkRectangle *background_area,
- gint x,
- gint y)
+ int x,
+ int y)
{
GtkCellRenderer *match;
GdkRectangle cell_alloc, aligned_area, inner_area;
gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer,
const gchar *attribute,
- gint column)
+ int column)
{
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (tree_column),
cell_renderer, attribute, column);
{
GtkTreeViewColumnPrivate *priv = tree_column->priv;
gchar *attribute;
- gint column;
+ int column;
attribute = va_arg (args, gchar *);
while (attribute != NULL)
{
- column = va_arg (args, gint);
+ column = va_arg (args, int);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->cell_area),
cell_renderer, attribute, column);
attribute = va_arg (args, gchar *);
**/
void
gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column,
- gint spacing)
+ int spacing)
{
GtkTreeViewColumnPrivate *priv;
*
* Returns: the spacing of @tree_column.
**/
-gint
+int
gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column)
{
GtkTreeViewColumnPrivate *priv;
*
* Returns: The current width of @tree_column.
**/
-gint
+int
gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
*
* Returns: The current X offset of @tree_column.
*/
-gint
+int
gtk_tree_view_column_get_x_offset (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
return tree_column->priv->x_offset;
}
-gint
+int
_gtk_tree_view_column_request_width (GtkTreeViewColumn *tree_column)
{
GtkTreeViewColumnPrivate *priv;
- gint real_requested_width;
+ int real_requested_width;
priv = tree_column->priv;
}
else if (gtk_tree_view_get_headers_visible (GTK_TREE_VIEW (priv->tree_view)))
{
- gint button_request;
- gint requested_width;
+ int button_request;
+ int requested_width;
gtk_cell_area_context_get_preferred_width (priv->cell_area_context, &requested_width, NULL);
requested_width += priv->padding;
}
else
{
- gint requested_width;
+ int requested_width;
gtk_cell_area_context_get_preferred_width (priv->cell_area_context, &requested_width, NULL);
requested_width += priv->padding;
**/
void
gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
- gint fixed_width)
+ int fixed_width)
{
GtkTreeViewColumnPrivate *priv;
*
* Returns: The fixed width of the column.
**/
-gint
+int
gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
**/
void
gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
- gint min_width)
+ int min_width)
{
GtkTreeViewColumnPrivate *priv;
*
* Returns: The minimum width of the @tree_column.
**/
-gint
+int
gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
**/
void
gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
- gint max_width)
+ int max_width)
{
GtkTreeViewColumnPrivate *priv;
*
* Returns: The maximum width of the @tree_column.
**/
-gint
+int
gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), -1);
**/
void
gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column,
- gint sort_column_id)
+ int sort_column_id)
{
GtkTreeViewColumnPrivate *priv;
* Returns: the current @sort_column_id for this column, or -1 if
* this column can’t be used for sorting.
**/
-gint
+int
gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column)
{
g_return_val_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column), 0);
int *height)
{
GtkTreeViewColumnPrivate *priv;
- gint min_width = 0, min_height = 0;
+ int min_width = 0, min_height = 0;
g_return_if_fail (GTK_IS_TREE_VIEW_COLUMN (tree_column));
gboolean
gtk_tree_view_column_cell_get_position (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer,
- gint *x_offset,
- gint *width)
+ int *x_offset,
+ int *width)
{
GtkTreeViewColumnPrivate *priv;
GdkRectangle cell_area;
void
_gtk_tree_view_column_push_padding (GtkTreeViewColumn *column,
- gint padding)
+ int padding)
{
column->priv->padding = MAX (column->priv->padding, padding);
}
-gint
+int
_gtk_tree_view_column_get_requested_width (GtkTreeViewColumn *column)
{
- gint requested_width;
+ int requested_width;
gtk_cell_area_context_get_preferred_width (column->priv->cell_area_context, &requested_width, NULL);
return requested_width + column->priv->padding;
}
-gint
+int
_gtk_tree_view_column_get_drag_x (GtkTreeViewColumn *column)
{
return column->priv->drag_x;
void gtk_tree_view_column_add_attribute (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer,
const gchar *attribute,
- gint column);
+ int column);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_attributes (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer,
GtkCellRenderer *cell_renderer);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_spacing (GtkTreeViewColumn *tree_column,
- gint spacing);
+ int spacing);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_spacing (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_visible (GtkTreeViewColumn *tree_column,
gboolean visible);
GDK_AVAILABLE_IN_ALL
GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_x_offset (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_x_offset (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_width (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_fixed_width (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_fixed_width (GtkTreeViewColumn *tree_column,
- gint fixed_width);
+ int fixed_width);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_min_width (GtkTreeViewColumn *tree_column,
- gint min_width);
+ int min_width);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_min_width (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_max_width (GtkTreeViewColumn *tree_column,
- gint max_width);
+ int max_width);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_max_width (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_clicked (GtkTreeViewColumn *tree_column);
*/
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_sort_column_id (GtkTreeViewColumn *tree_column,
- gint sort_column_id);
+ int sort_column_id);
GDK_AVAILABLE_IN_ALL
-gint gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column);
+int gtk_tree_view_column_get_sort_column_id (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_set_sort_indicator (GtkTreeViewColumn *tree_column,
gboolean setting);
GDK_AVAILABLE_IN_ALL
gboolean gtk_tree_view_column_cell_get_position (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell_renderer,
- gint *x_offset,
- gint *width);
+ int *x_offset,
+ int *width);
GDK_AVAILABLE_IN_ALL
void gtk_tree_view_column_queue_resize (GtkTreeViewColumn *tree_column);
GDK_AVAILABLE_IN_ALL
};
static gboolean cb_query_tooltip (GtkWidget *button,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data);
static gboolean
cb_query_tooltip (GtkWidget *button,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
guint flags_to_set;
guint flags_to_unset;
- gint old_scale_factor;
+ int old_scale_factor;
};
/* --- prototypes --- */
GtkTextDirection previous_direction);
static gboolean gtk_widget_real_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip);
static void gtk_widget_real_css_changed (GtkWidget *widget,
static void template_data_free (GtkWidgetTemplate*template_data);
static void gtk_widget_set_usize_internal (GtkWidget *widget,
- gint width,
- gint height);
+ int width,
+ int height);
static gboolean event_surface_is_still_viewable (GdkEvent *event);
/* --- variables --- */
-static gint GtkWidget_private_offset = 0;
+static int GtkWidget_private_offset = 0;
static gpointer gtk_widget_parent_class = NULL;
static guint widget_signals[LAST_SIGNAL] = { 0 };
GtkTextDirection gtk_default_direction = GTK_TEXT_DIR_LTR;
return !sequence_press_handled;
}
-static gint
+static int
_gtk_widget_set_sequence_state_internal (GtkWidget *widget,
GdkEventSequence *sequence,
GtkEventSequenceState state,
GtkWidget *target;
GList *group = NULL;
GdkEventSequence *seq;
- gint n_handled = 0;
+ int n_handled = 0;
guint i;
if (state != GTK_EVENT_SEQUENCE_CLAIMED &&
}
}
-static gint
+static int
get_number (GtkCssValue *value)
{
double d = _gtk_css_number_value_get (value, 100);
static void
adjust_for_align (GtkAlign align,
- gint natural_size,
- gint *allocated_pos,
- gint *allocated_size)
+ int natural_size,
+ int *allocated_pos,
+ int *allocated_size)
{
switch (align)
{
GtkAllocation *allocation)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
- gint natural_width, natural_height;
- gint min_width, min_height;
+ int natural_width, natural_height;
+ int min_width, min_height;
if (priv->halign == GTK_ALIGN_FILL && priv->valign == GTK_ALIGN_FILL)
return;
{
GtkWidget *parent_a;
GtkWidget *parent_b;
- gint depth_a = 0;
- gint depth_b = 0;
+ int depth_a = 0;
+ int depth_b = 0;
parent_a = widget_a;
while (parent_a->priv->parent)
static gboolean
gtk_widget_real_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip)
{
gboolean
gtk_widget_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_mode,
GtkTooltip *tooltip)
{
*
* Returns: the scale factor for @widget
*/
-gint
+int
gtk_widget_get_scale_factor (GtkWidget *widget)
{
GtkRoot *root;
static void
gtk_widget_set_usize_internal (GtkWidget *widget,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
gboolean changed = FALSE;
**/
void
gtk_widget_set_size_request (GtkWidget *widget,
- gint width,
- gint height)
+ int width,
+ int height)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (width >= -1);
**/
void
gtk_widget_get_size_request (GtkWidget *widget,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
void
gtk_widget_adjust_size_request (GtkWidget *widget,
GtkOrientation orientation,
- gint *minimum_size,
- gint *natural_size)
+ int *minimum_size,
+ int *natural_size)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
void
gtk_widget_adjust_baseline_request (GtkWidget *widget,
- gint *minimum_baseline,
- gint *natural_baseline)
+ int *minimum_baseline,
+ int *natural_baseline)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
GtkStateFlags new_flags, old_flags = priv->state_flags;
GtkStateData child_data;
GtkWidget *child;
- gint new_scale_factor = gtk_widget_get_scale_factor (widget);
+ int new_scale_factor = gtk_widget_get_scale_factor (widget);
priv->state_flags |= data->flags_to_set;
priv->state_flags &= ~(data->flags_to_unset);
gboolean expand)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
- gint expand_prop;
- gint expand_set_prop;
+ int expand_prop;
+ int expand_set_prop;
g_return_if_fail (GTK_IS_WIDGET (widget));
gboolean set)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
- gint prop;
+ int prop;
set = set != FALSE;
{
gchar *target;
AtkRelationType type;
- gint line;
- gint col;
+ int line;
+ int col;
} AtkRelationData;
static void
{
AtkObject *accessible;
AtkAction *action;
- gint i, n_actions;
+ int i, n_actions;
GSList *l;
accessible = gtk_widget_get_accessible (GTK_WIDGET (buildable));
*
* Returns: The start margin of @widget
*/
-gint
+int
gtk_widget_get_margin_start (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*/
void
gtk_widget_set_margin_start (GtkWidget *widget,
- gint margin)
+ int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*
* Returns: The end margin of @widget
*/
-gint
+int
gtk_widget_get_margin_end (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*/
void
gtk_widget_set_margin_end (GtkWidget *widget,
- gint margin)
+ int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*
* Returns: The top margin of @widget
*/
-gint
+int
gtk_widget_get_margin_top (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*/
void
gtk_widget_set_margin_top (GtkWidget *widget,
- gint margin)
+ int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*
* Returns: The bottom margin of @widget
*/
-gint
+int
gtk_widget_get_margin_bottom (GtkWidget *widget)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*/
void
gtk_widget_set_margin_bottom (GtkWidget *widget,
- gint margin)
+ int margin)
{
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
*/
struct _GtkRequisition
{
- gint width;
- gint height;
+ int width;
+ int height;
};
/* The widget is the base of the tree for displayable objects.
AtkObject * (* get_accessible) (GtkWidget *widget);
gboolean (* query_tooltip) (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tooltip,
GtkTooltip *tooltip);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_size_request (GtkWidget *widget,
- gint width,
- gint height);
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_widget_get_size_request (GtkWidget *widget,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_opacity (GtkWidget *widget,
double opacity);
GType widget_type);
GDK_AVAILABLE_IN_ALL
-gint gtk_widget_get_scale_factor (GtkWidget *widget);
+int gtk_widget_get_scale_factor (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
GdkDisplay * gtk_widget_get_display (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_valign (GtkWidget *widget,
GtkAlign align);
GDK_AVAILABLE_IN_ALL
-gint gtk_widget_get_margin_start (GtkWidget *widget);
+int gtk_widget_get_margin_start (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_margin_start (GtkWidget *widget,
- gint margin);
+ int margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_widget_get_margin_end (GtkWidget *widget);
+int gtk_widget_get_margin_end (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_margin_end (GtkWidget *widget,
- gint margin);
+ int margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_widget_get_margin_top (GtkWidget *widget);
+int gtk_widget_get_margin_top (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_margin_top (GtkWidget *widget,
- gint margin);
+ int margin);
GDK_AVAILABLE_IN_ALL
-gint gtk_widget_get_margin_bottom (GtkWidget *widget);
+int gtk_widget_get_margin_bottom (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_margin_bottom (GtkWidget *widget,
- gint margin);
+ int margin);
GDK_AVAILABLE_IN_ALL
gboolean gtk_widget_is_ancestor (GtkWidget *widget,
GskTransform *allocated_transform;
int allocated_width;
int allocated_height;
- gint allocated_size_baseline;
+ int allocated_size_baseline;
GskTransform *transform;
int width;
guint *out_n_controllers);
gboolean gtk_widget_query_tooltip (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_mode,
GtkTooltip *tooltip);
GtkSnapshot *snapshot);
void gtk_widget_adjust_size_request (GtkWidget *widget,
GtkOrientation orientation,
- gint *minimum_size,
- gint *natural_size);
+ int *minimum_size,
+ int *natural_size);
void gtk_widget_adjust_baseline_request (GtkWidget *widget,
- gint *minimum_baseline,
- gint *natural_baseline);
+ int *minimum_baseline,
+ int *natural_baseline);
void gtk_widget_forall (GtkWidget *widget,
GtkCallback callback,
guint focus_visible_timeout;
- gint scale;
+ int scale;
- gint title_height;
+ int title_height;
GtkWidget *title_box;
GtkWidget *titlebar;
GtkWidget *key_press_focus;
/* from last gtk_window_resize () - if > 0, indicates that
* we should resize to this size.
*/
- gint resize_width;
- gint resize_height;
+ int resize_width;
+ int resize_height;
/* Default size - used only the FIRST time we map a window,
* only if > 0.
*/
- gint default_width;
- gint default_height;
+ int default_width;
+ int default_height;
GtkWindowLastGeometryInfo last;
};
GdkEvent *event,
GtkWidget *widget);
-static gint gtk_window_focus (GtkWidget *widget,
+static int gtk_window_focus (GtkWidget *widget,
GtkDirectionType direction);
static void gtk_window_move_focus (GtkWidget *widget,
GtkDirectionType dir);
static void gtk_window_constrain_size (GtkWindow *window,
GdkGeometry *geometry,
guint flags,
- gint width,
- gint height,
- gint *new_width,
- gint *new_height);
+ int width,
+ int height,
+ int *new_width,
+ int *new_height);
static void gtk_window_update_fixed_size (GtkWindow *window,
GdkGeometry *new_geometry,
- gint new_width,
- gint new_height);
+ int new_width,
+ int new_height);
static void gtk_window_compute_hints (GtkWindow *window,
GdkGeometry *new_geometry,
guint *new_flags);
static void gtk_window_set_default_size_internal (GtkWindow *window,
gboolean change_width,
- gint width,
+ int width,
gboolean change_height,
- gint height);
+ int height);
static void update_themed_icon (GtkWindow *window);
static GList *icon_list_from_theme (GtkWindow *window,
}
}
-static gint
+static int
get_number (GtkCssValue *value)
{
double d = _gtk_css_number_value_get (value, 100);
static void
click_gesture_pressed_cb (GtkGestureClick *gesture,
- gint n_press,
+ int n_press,
gdouble x,
gdouble y,
GtkWindow *window)
GtkIconTheme *icon_theme;
GtkIconPaintable *info;
GdkTexture *texture;
- gint *sizes;
- gint i;
+ int *sizes;
+ int i;
icon_theme = gtk_icon_theme_get_for_display (priv->display);
static void
gtk_window_update_csd_size (GtkWindow *window,
- gint *width,
- gint *height,
- gint apply)
+ int *width,
+ int *height,
+ int apply)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkBorder window_border = { 0 };
- gint w, h;
+ int w, h;
if (!priv->decorated ||
priv->fullscreen)
gtk_widget_get_visible (priv->title_box) &&
gtk_widget_get_child_visible (priv->title_box))
{
- gint minimum_height;
- gint natural_height;
+ int minimum_height;
+ int natural_height;
gtk_widget_measure (priv->title_box, GTK_ORIENTATION_VERTICAL, -1,
&minimum_height, &natural_height,
static void
gtk_window_set_default_size_internal (GtkWindow *window,
gboolean change_width,
- gint width,
+ int width,
gboolean change_height,
- gint height)
+ int height)
{
GtkWindowGeometryInfo *info;
*/
void
gtk_window_set_default_size (GtkWindow *window,
- gint width,
- gint height)
+ int width,
+ int height)
{
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (width >= -1);
**/
void
gtk_window_get_default_size (GtkWindow *window,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWindowGeometryInfo *info;
**/
void
gtk_window_resize (GtkWindow *window,
- gint width,
- gint height)
+ int width,
+ int height)
{
GtkWindowGeometryInfo *info;
*/
void
gtk_window_get_size (GtkWindow *window,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
- gint w, h;
+ int w, h;
g_return_if_fail (GTK_IS_WINDOW (window));
static void
gtk_window_guess_default_size (GtkWindow *window,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWidget *widget;
static void
gtk_window_compute_configure_request_size (GtkWindow *window,
guint flags,
- gint *width,
- gint *height)
+ int *width,
+ int *height)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWindowGeometryInfo *info;
/* Take width of shadows/headerbar into account. We want to set the
* default size of the content area and not the window area.
*/
- gint default_width_csd = info->default_width;
- gint default_height_csd = info->default_height;
+ int default_width_csd = info->default_width;
+ int default_height_csd = info->default_height;
gtk_window_update_csd_size (window,
&default_width_csd, &default_height_csd,
INCLUDE_CSD_SIZE);
}
else if (info)
{
- gint resize_width_csd = info->resize_width;
- gint resize_height_csd = info->resize_height;
+ int resize_width_csd = info->resize_width;
+ int resize_height_csd = info->resize_height;
gtk_window_update_csd_size (window,
&resize_width_csd, &resize_height_csd,
INCLUDE_CSD_SIZE);
gtk_window_constrain_size (GtkWindow *window,
GdkGeometry *geometry,
guint flags,
- gint width,
- gint height,
- gint *new_width,
- gint *new_height)
+ int width,
+ int height,
+ int *new_width,
+ int *new_height)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
guint geometry_flags;
static void
gtk_window_update_fixed_size (GtkWindow *window,
GdkGeometry *new_geometry,
- gint new_width,
- gint new_height)
+ int new_width,
+ int new_height)
{
GtkWindowPrivate *priv = gtk_window_get_instance_private (window);
GtkWindowGeometryInfo *info;
info = gtk_window_get_geometry_info (window, FALSE);
if (info)
{
- gint default_width_csd = info->default_width;
- gint default_height_csd = info->default_height;
+ int default_width_csd = info->default_width;
+ int default_height_csd = info->default_height;
gtk_window_update_csd_size (window,
&default_width_csd, &default_height_csd,
if (info->default_width > -1)
{
- gint w = MAX (MAX (default_width_csd, new_width), new_geometry->min_width);
+ int w = MAX (MAX (default_width_csd, new_width), new_geometry->min_width);
new_geometry->min_width = w;
new_geometry->max_width = w;
}
if (info->default_height > -1)
{
- gint h = MAX (MAX (default_height_csd, new_height), new_geometry->min_height);
+ int h = MAX (MAX (default_height_csd, new_height), new_geometry->min_height);
new_geometry->min_height = h;
new_geometry->max_height = h;
}
static void
warn_response (GtkDialog *dialog,
- gint response)
+ int response)
{
GtkWidget *check;
gboolean remember;
*/
GDK_AVAILABLE_IN_ALL
void gtk_window_set_default_size (GtkWindow *window,
- gint width,
- gint height);
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_window_get_default_size (GtkWindow *window,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
GDK_AVAILABLE_IN_ALL
void gtk_window_resize (GtkWindow *window,
- gint width,
- gint height);
+ int width,
+ int height);
GDK_AVAILABLE_IN_ALL
void gtk_window_get_size (GtkWindow *window,
- gint *width,
- gint *height);
+ int *width,
+ int *height);
GDK_AVAILABLE_IN_ALL
GtkWindowGroup *gtk_window_get_group (GtkWindow *window);
perform_titlebar_action (GtkWindowHandle *self,
GdkEvent *event,
guint button,
- gint n_press)
+ int n_press)
{
GtkSettings *settings;
gchar *action = NULL;
add_group (GtkInspectorActions *sl,
GActionGroup *group)
{
- gint i;
+ int i;
gchar **names;
names = g_action_group_list_actions (group);
add_muxer (GtkInspectorActions *sl,
GtkActionMuxer *muxer)
{
- gint i;
+ int i;
gchar **names;
names = gtk_action_muxer_list_actions (muxer);
gtk_cell_renderer_graph_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
const GdkRectangle *cell_area,
- gint *x_offset,
- gint *y_offset,
- gint *width,
- gint *height)
+ int *x_offset,
+ int *y_offset,
+ int *width,
+ int *height)
{
int xpad, ypad;
static gboolean
query_tooltip_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
GtkInspectorCssEditor *ce)
if (keyboard_tip)
{
- gint offset;
+ int offset;
g_object_get (ce->priv->text, "cursor-position", &offset, NULL);
gtk_text_buffer_get_iter_at_offset (ce->priv->text, &iter, offset);
}
else
{
- gint bx, by, trailing;
+ int bx, by, trailing;
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (ce->priv->view), GTK_TEXT_WINDOW_TEXT,
x, y, &bx, &by);
static void
save_response (GtkWidget *dialog,
- gint response,
+ int response,
GtkInspectorCssEditor *ce)
{
gtk_widget_hide (dialog);
if (state)
{
GString *str;
- gint i;
+ int i;
gboolean first = TRUE;
str = g_string_new ("");
gtk_inspector_css_node_tree_init (GtkInspectorCssNodeTree *cnt)
{
GtkInspectorCssNodeTreePrivate *priv;
- gint i;
+ int i;
cnt->priv = gtk_inspector_css_node_tree_get_instance_private (cnt);
gtk_widget_init_template (GTK_WIDGET (cnt));
GtkCssStyle *new_style)
{
GtkInspectorCssNodeTreePrivate *priv = cnt->priv;
- gint i;
+ int i;
for (i = 0; i < _gtk_css_style_property_get_n_properties (); i++)
{
GtkListBox *list,
const gchar *name,
gboolean value,
- gint indent)
+ int indent)
{
GtkWidget *row, *box, *label, *check;
GtkListBox *list,
const char *name,
const char *value,
- gint indent)
+ int indent)
{
GtkWidget *box;
GtkWidget *label;
gchar *name;
gchar *value;
GdkRectangle rect;
- gint scale;
+ int scale;
char *scale_str = NULL;
const char *manufacturer;
const char *model;
struct _GtkTreeModelCssNodePrivate
{
GtkTreeModelCssNodeGetFunc get_func;
- gint n_columns;
+ int n_columns;
GType *column_types;
GtkCssNode *root;
static GtkCssNode *
get_nth_child (GtkCssNode *node,
- gint i)
+ int i)
{
for (node = gtk_css_node_get_first_child (node);
node != NULL && i > 0;
return GTK_TREE_MODEL_ITERS_PERSIST;
}
-static gint
+static int
gtk_tree_model_css_node_get_n_columns (GtkTreeModel *tree_model)
{
GtkTreeModelCssNode *nodemodel = GTK_TREE_MODEL_CSS_NODE (tree_model);
static GType
gtk_tree_model_css_node_get_column_type (GtkTreeModel *tree_model,
- gint column)
+ int column)
{
GtkTreeModelCssNode *nodemodel = GTK_TREE_MODEL_CSS_NODE (tree_model);
GtkTreeModelCssNodePrivate *priv = nodemodel->priv;
static void
gtk_tree_model_css_node_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GtkTreeModelCssNode *nodemodel = GTK_TREE_MODEL_CSS_NODE (tree_model);
return gtk_css_node_get_first_child (node) != NULL;
}
-static gint
+static int
gtk_tree_model_css_node_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
gtk_tree_model_css_node_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
GtkTreeModelCssNode *nodemodel = GTK_TREE_MODEL_CSS_NODE (tree_model);
GtkTreeModelCssNodePrivate *priv = nodemodel->priv;
GtkTreeModel *
gtk_tree_model_css_node_new (GtkTreeModelCssNodeGetFunc get_func,
- gint n_columns,
+ int n_columns,
...)
{
GtkTreeModel *result;
va_list args;
GType *types;
- gint i;
+ int i;
g_return_val_if_fail (get_func != NULL, NULL);
g_return_val_if_fail (n_columns > 0, NULL);
GtkTreeModel *
gtk_tree_model_css_node_newv (GtkTreeModelCssNodeGetFunc get_func,
- gint n_columns,
+ int n_columns,
GType *types)
{
GtkTreeModelCssNode *result;
GType gtk_tree_model_css_node_get_type (void) G_GNUC_CONST;
GtkTreeModel *gtk_tree_model_css_node_new (GtkTreeModelCssNodeGetFunc get_func,
- gint n_columns,
+ int n_columns,
...);
GtkTreeModel *gtk_tree_model_css_node_newv (GtkTreeModelCssNodeGetFunc get_func,
- gint n_columns,
+ int n_columns,
GType *types);
void gtk_tree_model_css_node_set_root_node (GtkTreeModelCssNode *model,
G_DEFINE_TYPE (GtkLayoutOverlay, gtk_layout_overlay, GTK_TYPE_INSPECTOR_OVERLAY)
-static gint
+static int
get_number (GtkCssValue *value)
{
double d = _gtk_css_number_value_get (value, 100);
add_item (GtkInspectorMenu *sl,
GtkStackPage *page,
GMenuModel *menu,
- gint idx,
+ int idx,
GtkTreeIter *parent)
{
GtkTreeIter iter;
GMenuModel *menu,
GtkTreeIter *parent)
{
- gint n_items;
- gint i;
+ int n_items;
+ int i;
g_object_set (page, "visible", TRUE, NULL);
{
GFlagsClass *fclass;
GString *str;
- gint i;
+ int i;
str = g_string_new ("");
{
GValue val = G_VALUE_INIT;
GEnumClass *eclass;
- gint i;
+ int i;
eclass = G_ENUM_CLASS (g_type_class_peek (pspec->value_type));
gboolean active;
GFlagsClass *fclass;
guint flags;
- gint i;
+ int i;
GValue val = G_VALUE_INIT;
active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button));
GValue val = G_VALUE_INIT;
GFlagsClass *fclass;
guint flags;
- gint i;
+ int i;
GtkPopover *popover;
GtkWidget *sw;
GtkWidget *viewport;
gunichar old_val = unichar_get_value (entry);
GValue val = G_VALUE_INIT;
gchar buf[7];
- gint len;
+ int len;
g_value_init (&val, pspec->value_type);
get_property_value (object, pspec, &val);
{
GEnumClass *eclass;
char **names;
- gint j;
+ int j;
eclass = G_ENUM_CLASS (g_type_class_ref (spec->value_type));
GtkWidget *sw;
GtkWidget *popover;
GFlagsClass *fclass;
- gint j;
+ int j;
popover = gtk_popover_new ();
prop_edit = gtk_menu_button_new ();
GParamSpec *pspec,
GtkInspectorPropEditor *self)
{
- gint col;
+ int col;
gpointer layout;
GtkCellRenderer *cell;
GtkCellArea *area;
gpointer layout;
GtkCellArea *area;
GtkTreeModel *model = NULL;
- gint col = -1;
+ int col = -1;
GtkWidget *label;
GtkWidget *button;
GtkWidget *box;
GtkWidget *dropdown;
GListStore *store;
GtkListItemFactory *factory;
- gint i;
+ int i;
AttributeHolder *holder;
gboolean sensitive;
GVariant *minimum, *maximum;
GVariant *default_value;
- gint ref_count;
+ int ref_count;
};
typedef struct
gsize *size_out)
{
gchar **names;
- gint i;
+ int i;
GListStore *result;
result = g_list_store_new (RESOURCE_TYPE_HOLDER);
names = g_resources_enumerate_children (path, 0, NULL);
for (i = 0; names[i]; i++)
{
- gint len;
+ int len;
gchar *p;
gboolean has_slash;
- gint count;
+ int count;
gsize size;
GListModel *children;
ResourceHolder *holder;
static GListModel *
load_resources (void)
{
- gint count = 0;
+ int count = 0;
gsize size = 0;
return load_resources_recurse ("/", &count, &size);
G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorStatistics, gtk_inspector_statistics, GTK_TYPE_BOX)
-static gint
+static int
add_type_count (GtkInspectorStatistics *sl, GType type)
{
- gint cumulative;
- gint self;
+ int cumulative;
+ int self;
GType *children;
guint n_children;
- gint i;
+ int i;
TypeData *data;
cumulative = 0;
GtkTreeIter *iter,
gpointer data)
{
- gint column;
- gint count;
+ int column;
+ int count;
gchar *text;
column = GPOINTER_TO_INT (data);
GtkTreeIter *iter,
gpointer data)
{
- gint column;
- gint count1;
- gint count2;
+ int column;
+ int count1;
+ int count2;
gchar *text;
column = GPOINTER_TO_INT (data);
static gboolean
match_row (GtkTreeModel *model,
- gint column,
+ int column,
const gchar *key,
GtkTreeIter *iter,
gpointer data)
gchar **strv)
{
GtkWidget *child;
- gint i;
+ int i;
editor->blocked = TRUE;
GtkTreeIter *iter,
gpointer data)
{
- gint num;
+ int num;
GValue gvalue = { 0, };
gchar *value;
static void
add_columns (GtkInspectorTreeData *sl)
{
- gint n_columns;
+ int n_columns;
GtkCellRenderer *cell;
GType type;
gchar *title;
GtkTreeViewColumn *col;
- gint i;
+ int i;
n_columns = gtk_tree_model_get_n_columns (sl->object);
for (i = 0; i < n_columns; i++)
const gchar *name;
GType *interfaces;
GType tmp;
- gint i;
+ int i;
GtkWidget *child;
g_return_if_fail (GTK_IS_INSPECTOR_TYPE_POPOVER (self));
gboolean update_entry)
{
g_object_set (gtk_settings_get_for_display (vis->display),
- "gtk-xft-dpi", (gint)(factor * 96 * 1024),
+ "gtk-xft-dpi", (int)(factor * 96 * 1024),
NULL);
if (update_adjustment)
static void
cursor_size_changed (GtkAdjustment *adjustment, GtkInspectorVisual *vis)
{
- gint size;
+ int size;
size = gtk_adjustment_get_value (adjustment);
g_object_set (gtk_settings_get_for_display (vis->display), "gtk-cursor-theme-size", size, NULL);
static void
init_cursor_size (GtkInspectorVisual *vis)
{
- gint size;
+ int size;
g_object_get (gtk_settings_get_for_display (vis->display), "gtk-cursor-theme-size", &size, NULL);
if (size == 0)
static void
scale_changed (GtkAdjustment *adjustment, GtkInspectorVisual *vis)
{
- gint scale;
+ int scale;
scale = gtk_adjustment_get_value (adjustment);
gdk_x11_display_set_surface_scale (vis->display, scale);
#define TREE_TEXT_SCALE 0.8
-#define TREE_CHECKBOX_SIZE (gint)(0.8 * 13)
+#define TREE_CHECKBOX_SIZE (int)(0.8 * 13)
typedef struct
{
GdkSeat *grab_seat;
GtkInspectorOverlay *flash_overlay;
- gint flash_count;
- gint flash_cnx;
+ int flash_count;
+ int flash_cnx;
GArray *objects;
static void
size_prepared_cb (GdkPixbufLoader *loader,
- gint width,
- gint height,
+ int width,
+ int height,
gpointer data)
{
gdouble *scale = data;
static void
size_prepared_cb2 (GdkPixbufLoader *loader,
- gint width,
- gint height,
+ int width,
+ int height,
gpointer data)
{
int *scales = data;
{
GtkBuilder *builder;
GError *error = NULL;
- gint ret;
+ int ret;
GSList *list, *l;
GObject *object;
const gchar *name;
{ "GtkGridLayoutChild", "left-attach", PROP_KIND_LAYOUT },
};
gboolean found;
- gint k;
+ int k;
const char *class_name;
class_name = g_type_name (pspec->owner_type);
{ "GtkStack", "needs-attention", PROP_KIND_PACKING },
};
gboolean found;
- gint k;
+ int k;
char *canonical_name;
canonical_name = g_strdup (property_name);
property_can_be_omitted (Element *element,
MyParserData *data)
{
- gint i;
+ int i;
gboolean bound;
gboolean translatable;
const char *class_name;
};
gchar *canonical_name;
gboolean found;
- gint i, k;
+ int i, k;
PropKind kind;
kind = get_prop_kind (element);
GObject *object;
GtkBuilder *builder;
GError *error = NULL;
- gint ret;
+ int ret;
/* Only make a fake type if it doesn't exist yet.
* This lets us e.g. validate the GtkFileChooserWidget template.
{
GtkBuilder *builder;
GError *error = NULL;
- gint ret;
+ int ret;
gchar *class_name = NULL;
gchar *parent_name = NULL;
if (info->flags & CHECK_STRINGS)
{
- gint i;
+ int i;
gchar c;
/* assume no string is longer than 1k */
if (info->flags & CHECK_STRINGS)
{
- gint i;
+ int i;
gchar c;
/* assume no string is longer than 1k */
guint32 offset)
{
guint32 directory_offset;
- gint i;
+ int i;
check ("offset, directory list", get_uint32 (info, offset, &info->n_directories));
guint32 offset)
{
guint32 n_display_names, ofs;
- gint i;
+ int i;
check ("offset, display name list",
get_uint32 (info, offset, &n_display_names));
guint32 offset)
{
guint32 n_images;
- gint i;
+ int i;
check ("offset, image list", get_uint32 (info, offset, &n_images));
guint32 offset)
{
guint32 n_buckets, icon_offset;
- gint i;
+ int i;
check ("offset, hash size", get_uint32 (info, offset, &n_buckets));
is_cache_up_to_date (const gchar *path)
{
gchar *cache_path;
- gint retval;
+ int retval;
cache_path = g_build_filename (path, CACHE_NAME, NULL);
retval = g_stat (cache_path, &cache_dir_stat);
char **display_names;
guint32 offset;
- gint size;
+ int size;
} IconData;
static GHashTable *image_data_hash = NULL;
char *str;
char *split_point;
int i;
- gint *ivalues;
+ int *ivalues;
GError *error = NULL;
gchar **keys;
gsize n_keys;
const gchar *subdir,
GHashTable *files,
GList *directories,
- gint depth)
+ int depth)
{
GHashTable *dir_hash;
GDir *dir;
HashNode *next;
gchar *name;
GList *image_list;
- gint offset;
+ int offset;
};
static guint
}
typedef struct {
- gint size;
+ int size;
HashNode **nodes;
} HashContext;
{
guint8 *s;
guint len;
- gint i;
+ int i;
GdkPixdata *pixdata = &image_data->pixdata;
/* Type 0 is GdkPixdata */
write_card32 (cache, dir_list_offset));
}
-static gint
+static int
get_image_meta_data_size (Image *image)
{
- gint i;
+ int i;
/* The complication with storing the size in both
* IconData and Image is necessary since we attribute
return image->icon_data_size;
}
-static gint
+static int
get_image_pixel_data_size (Image *image)
{
/* The complication with storing the size in both
return image->pixel_data_size;
}
-static gint
+static int
get_image_data_size (Image *image)
{
- gint len;
+ int len;
len = 0;
gchar *cache_path;
gchar *data;
gsize len;
- gint i;
+ int i;
cache_path = g_build_filename (path, CACHE_NAME, NULL);
if (!g_file_get_contents (cache_path, &data, &len, NULL))
RestProxyCall *call;
RestProxy *rest;
GVariant *output;
- gint expires_in = 0;
+ int expires_in = 0;
GError *error = NULL;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source),
GTask *task = user_data;
GtkCloudprintAccount *account = g_task_get_task_data (task);
GVariant *output;
- gint expires_in = 0;
+ int expires_in = 0;
GError *error = NULL;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source),
*value = NULL;
GVariantIter *iter = NULL;
guint i, required_len;
- gint pw_field = -1;
+ int pw_field = -1;
task = user_data;
task_data = g_task_get_task_data (task);
static void
cleanup_task_data (gpointer data)
{
- gint i;
+ int i;
SecretsServiceData *task_data = data;
g_free (task_data->collection_path);
GtkCupsRequest *
gtk_cups_request_new_with_username (http_t *connection,
GtkCupsRequestType req_type,
- gint operation_id,
+ int operation_id,
GIOChannel *data_io,
const char *server,
const char *resource,
GtkCupsRequest *
gtk_cups_request_new (http_t *connection,
GtkCupsRequestType req_type,
- gint operation_id,
+ int operation_id,
GIOChannel *data_io,
const char *server,
const char *resource)
void
gtk_cups_request_set_ipp_version (GtkCupsRequest *request,
- gint major,
- gint minor)
+ int major,
+ int minor)
{
ippSetVersion (request->ipp_request, major, minor);
}
{
GtkCupsConnectionState result = GTK_CUPS_CONNECTION_NOT_AVAILABLE;
http_addrlist_t *iter;
- gint error_code;
- gint flags;
- gint code;
+ int error_code;
+ int flags;
+ int code;
if (test == NULL)
return GTK_CUPS_CONNECTION_NOT_AVAILABLE;
gchar *server;
gchar *resource;
GIOChannel *data_io;
- gint attempts;
+ int attempts;
GtkCupsResult *result;
- gint state;
+ int state;
GtkCupsPollState poll_state;
guint64 bytes_received;
gchar *password;
gchar *username;
- gint own_http : 1;
- gint need_password : 1;
- gint need_auth_info : 1;
+ int own_http : 1;
+ int need_password : 1;
+ int need_auth_info : 1;
gchar **auth_info_required;
gchar **auth_info;
GtkCupsPasswordState password_state;
http_addrlist_t *addrlist;
http_addrlist_t *current_addr;
http_addrlist_t *last_wrong_addr;
- gint socket;
+ int socket;
};
#define GTK_CUPS_REQUEST_START 0
GtkCupsRequest * gtk_cups_request_new_with_username (http_t *connection,
GtkCupsRequestType req_type,
- gint operation_id,
+ int operation_id,
GIOChannel *data_io,
const char *server,
const char *resource,
const char *username);
GtkCupsRequest * gtk_cups_request_new (http_t *connection,
GtkCupsRequestType req_type,
- gint operation_id,
+ int operation_id,
GIOChannel *data_io,
const char *server,
const char *resource);
const gchar *option,
const gchar *value);
void gtk_cups_request_set_ipp_version (GtkCupsRequest *request,
- gint major,
- gint minor);
+ int major,
+ int minor);
gboolean gtk_cups_result_is_error (GtkCupsResult *result);
ipp_t * gtk_cups_result_get_response (GtkCupsResult *result);
GtkCupsErrorType gtk_cups_result_get_error_type (GtkCupsResult *result);
gchar *path;
/* Base64 encoding state */
- gint b64state;
- gint b64save;
+ int b64state;
+ int b64save;
} _PrintStreamData;
static void
{
GVariant *objects;
GList *result = NULL;
- gint i, j, k;
+ int i, j, k;
g_variant_get (output, "(@a{oa{sa{sv}}})",
&objects);
if (gtk_print_job_get_pages (print_job) == GTK_PRINT_PAGES_RANGES)
{
GtkPageRange *page_ranges;
- gint num_page_ranges;
+ int num_page_ranges;
page_ranges = gtk_print_settings_get_page_ranges (settings, &num_page_ranges);
gtk_print_job_set_page_ranges (print_job, page_ranges, num_page_ranges);
}
guint list_printers_poll;
guint list_printers_pending : 1;
- gint list_printers_attempts;
+ int list_printers_attempts;
guint got_default_printer : 1;
guint default_printer_poll;
GtkCupsConnectionTest *cups_connection_test;
- gint reading_ppds;
+ int reading_ppds;
GList *requests;
GHashTable *auth;
ppd_attr_t *ppd_attr_screen_freq = NULL;
ppd_attr_t *ppd_attr_res_screen_freq = NULL;
gchar *res_string = NULL;
- gint level = 2;
+ int level = 2;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
GtkPrinterCups *printer = data->printer;
gboolean custom_value = FALSE;
gchar *new_value = NULL;
- gint i;
+ int i;
if (!key || !value)
return;
gchar *username = NULL;
gchar *hostname = NULL;
gchar *password = NULL;
- gint length;
- gint i;
+ int length;
+ int i;
length = g_strv_length (auth_info_required);
gchar **auth_info_default;
gchar **auth_info_display;
gboolean *auth_info_visible;
- gint length = 3;
- gint i;
+ int length = 3;
+ int i;
if (dispatch->backend->authentication_lock)
return G_SOURCE_REMOVE;
}
else
{
- gint length;
- gint i;
+ int length;
+ int i;
length = g_strv_length (dispatch->request->auth_info_required);
GtkPrintCupsDispatchWatch *dispatch;
gchar **auth_info;
GError *error = NULL;
- gint i;
+ int i;
task = (GTask *) res;
dispatch = user_data;
const char *printer_uri;
gchar *prompt = NULL;
char *printer_name = NULL;
- gint length;
- gint i;
+ int length;
+ int i;
gboolean *auth_info_visible = NULL;
gchar **auth_info_default = NULL;
gchar **auth_info_display = NULL;
static gboolean
cups_dispatch_watch_prepare (GSource *source,
- gint *timeout_)
+ int *timeout_)
{
GtkPrintCupsDispatchWatch *dispatch;
gboolean result;
static void
cups_begin_polling_info (GtkPrintBackendCups *print_backend,
GtkPrintJob *job,
- gint job_id)
+ int job_id)
{
CupsJobPollData *data;
g_signal_emit_by_name (backend, "printer-removed", printer);
}
-static gint
+static int
find_printer (GtkPrinter *printer,
const gchar *find_name)
{
gchar *state_msg;
const gchar *reason_msg;
PrinterStateLevel reason_level;
- gint state;
- gint job_count;
+ int state;
+ int job_count;
gboolean is_paused;
gboolean is_accepting_jobs;
const gchar *default_cover_before;
gboolean avahi_printer;
gchar *avahi_resource_path;
gchar **auth_info_required;
- gint default_number_up;
+ int default_number_up;
guchar ipp_version_major;
guchar ipp_version_minor;
gboolean supports_copies;
}
}
-static gint
+static int
ipp_version_cmp (guchar ipp_version_major1,
guchar ipp_version_minor1,
guchar ipp_version_major2,
ipp_attribute_t *attr,
PrinterSetupInfo *info)
{
- gint i, j;
+ int i, j;
if (strcmp (ippGetName (attr), "printer-name") == 0 &&
ippGetValueTag (attr) == IPP_TAG_NAME)
info->printer_name = ippGetString (attr, 0, NULL);
{
ipp_attribute_t *iter;
ipp_t *col;
- gint num_of_margins = 0;
+ int num_of_margins = 0;
for (i = 0; i < ippGetCount (attr); i++)
{
static void
set_info_state_message (PrinterSetupInfo *info)
{
- gint i;
+ int i;
if (info->state_msg == NULL || strlen (info->state_msg) == 0)
{
gchar *printer_uri;
gchar *location;
gchar *host;
- gint port;
+ int port;
gchar *printer_name;
gchar *name;
gchar *resource_path;
gchar *key;
gchar *value;
gsize length;
- gint interface;
- gint protocol;
- gint aprotocol;
- gint i, j;
+ int interface;
+ int protocol;
+ int aprotocol;
+ int i, j;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
gchar *type;
gchar *domain;
guint flags;
- gint interface;
- gint protocol;
+ int interface;
+ int protocol;
if (g_strcmp0 (signal_name, "ItemNew") == 0)
{
GtkPrintBackendCups *cups_backend;
GVariant *output;
GError *error = NULL;
- gint i;
+ int i;
output = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source_object),
res,
GetPPDData *data;
int fd;
const gchar *hostname;
- gint port;
+ int port;
cups_printer = GTK_PRINTER_CUPS (printer);
* https://mail.gnome.org/archives/desktop-devel-list/2016-March/msg00075.html
*/
static gchar *
-get_ipp_choice_translation_string (gint index,
+get_ipp_choice_translation_string (int index,
guint i)
{
gchar *translation;
static gboolean
string_in_table (const gchar *str,
const gchar *table[],
- gint table_len)
+ int table_len)
{
return bsearch (&str, table, table_len, sizeof (char *), (void *)strptr_cmp) != NULL;
}
ppd_group_t *toplevel_group,
GtkPrintSettings *settings)
{
- gint i;
+ int i;
const gchar *name;
/* Ignore installable options */
gchar **gtk_option_name,
gchar **translation)
{
- gint i;
+ int i;
*gtk_option_name = NULL;
*translation = NULL;
gchar *translation = NULL;
gsize ipp_choice_length;
gchar *endptr;
- gint i;
+ int i;
for (i = 0; ipp_choice_translations[i].ipp_option_name != NULL; i++)
{
char **cover = NULL;
char **cover_display = NULL;
char **cover_display_translated = NULL;
- gint num_of_covers = 0;
+ int num_of_covers = 0;
gconstpointer value;
- gint j;
+ int j;
/* Translators, this string is used to label the pages-per-sheet option
* in the print dialog
if (strcmp (name, "cups-job-sheets") == 0)
{
gchar **values;
- gint num_values;
+ int num_values;
values = g_strsplit (opts[i].value, ",", 2);
num_values = g_strv_length (values);
static void
map_settings_to_option (GtkPrinterOption *option,
const NameMapping table[],
- gint n_elements,
+ int n_elements,
GtkPrintSettings *settings,
const gchar *standard_name,
const gchar *cups_name,
static void
map_option_to_settings (const gchar *value,
const NameMapping table[],
- gint n_elements,
+ int n_elements,
GtkPrintSettings *settings,
const gchar *standard_name,
const gchar *cups_name,
{
GtkPrintPages pages;
GtkPageRange *ranges;
- gint n_ranges;
+ int n_ranges;
GtkPageSet page_set;
GtkPaperSize *paper_size;
const char *ppd_paper_name;
create_page_setup_from_media (gchar *media,
MediaSize *media_size,
gboolean media_margin_default_set,
- gint media_bottom_margin_default,
- gint media_top_margin_default,
- gint media_left_margin_default,
- gint media_right_margin_default)
+ int media_bottom_margin_default,
+ int media_top_margin_default,
+ int media_left_margin_default,
+ int media_right_margin_default)
{
GtkPageSetup *page_setup;
GtkPaperSize *paper_size;
format_from_settings (GtkPrintSettings *settings)
{
const gchar *value;
- gint i;
+ int i;
if (settings == NULL)
return N_FORMATS;
{
GtkPrinterOption *format_option;
const gchar *value;
- gint i;
+ int i;
format_option = gtk_printer_option_set_lookup (set, "output-file-format");
if (format_option && format_option->value)
if (dot)
{
- gint i;
+ int i;
/* check if the file extension matches one of the known ones */
for (i = 0; i < N_FORMATS; i++)
const char *format_names[N_FORMATS] = { N_("PDF"), N_("PostScript"), N_("SVG") };
const char *supported_formats[N_FORMATS];
const char *display_format_names[N_FORMATS];
- gint n_formats = 0;
+ int n_formats = 0;
OutputFormat format;
char *uri;
- gint current_format = 0;
+ int current_format = 0;
_OutputFormatChangedData *format_changed_data;
format = format_from_settings (settings);
gdouble scale;
GtkPrintPages pages;
GtkPageRange *ranges;
- gint n_ranges;
+ int n_ranges;
OutputFormat format;
pages = gtk_print_settings_get_print_pages (settings);
GError *print_error = NULL;
_PrintStreamData *ps;
GtkPrintSettings *settings;
- gint argc;
- gint in_fd;
+ int argc;
+ int in_fd;
gchar **argv = NULL;
const char *cmd_line;
double scale;
GtkPrintPages pages;
GtkPageRange *ranges;
- gint n_ranges;
+ int n_ranges;
pages = gtk_print_settings_get_print_pages (settings);
gtk_print_job_set_pages (print_job, pages);
gchar *original_device_uri;
gchar *printer_uri;
gchar *hostname;
- gint port;
+ int port;
gchar **auth_info_required;
gchar *original_hostname;
gchar *original_resource;
- gint original_port;
+ int original_port;
gboolean request_original_uri; /* Request PPD from original host */
ipp_pstate_t state;
gchar *media_default;
GList *media_supported;
GList *media_size_supported;
- gint media_bottom_margin_default;
- gint media_top_margin_default;
- gint media_left_margin_default;
- gint media_right_margin_default;
+ int media_bottom_margin_default;
+ int media_top_margin_default;
+ int media_left_margin_default;
+ int media_right_margin_default;
gboolean media_margin_default_set;
gchar *sides_default;
GList *sides_supported;
gchar *default_cover_before;
gchar *default_cover_after;
- gint default_number_up;
+ int default_number_up;
gboolean remote;
guint get_remote_ppd_poll;
- gint get_remote_ppd_attempts;
+ int get_remote_ppd_attempts;
GtkCupsConnectionTest *remote_cups_connection_test;
#ifdef HAVE_COLORD
GObject parent;
gchar *label;
- gint id;
+ int id;
} MyObject;
typedef struct
return label;
}
-static gint
+static int
compare_items (gconstpointer a, gconstpointer b, gpointer data)
{
- gint id_a, id_b;
+ int id_a, id_b;
g_object_get ((gpointer)a, "id", &id_a, NULL);
g_object_get ((gpointer)b, "id", &id_b, NULL);
static void
add_some (GtkButton *button, GListStore *store)
{
- gint n, i;
+ int n, i;
guint n_items;
GObject *obj;
gchar *label;
static void
remove_some (GtkButton *button, GListStore *store)
{
- gint n, i;
+ int n, i;
guint n_items;
for (n = 0; n < 50; n++)
{
GtkWidget *window, *grid, *sw, *box, *button;
GListStore *store;
- gint i;
+ int i;
gtk_init ();
get_content (void)
{
GString *s;
- gint i;
+ int i;
s = g_string_new ("");
for (i = 1; i <= 150; i++)
static void
mode_changed (GtkComboBox *combo, GtkScrolledWindow *sw)
{
- gint active = gtk_combo_box_get_active (combo);
+ int active = gtk_combo_box_get_active (combo);
gtk_scrolled_window_set_overlay_scrolling (sw, active == 1);
}
static void
fill_text_view (GtkWidget *tv, const gchar *text)
{
- gint i;
+ int i;
GString *s;
s = g_string_new ("");
g_print ("%u %d %u\n", keyval, mask, hardware_keycode);
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
- 0, (gint)mask,
+ 0, (int)mask,
1, keyval,
2, hardware_keycode,
-1);
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *rend;
- gint i;
+ int i;
GtkWidget *box, *entry;
/* create window */
return window;
}
-gint
-main (gint argc, gchar **argv)
+int
+main (int argc, gchar **argv)
{
GtkWidget *dialog;
static void
dialog_response (GtkDialog *d,
- gint response_id,
+ int response_id,
gpointer user_data)
{
GAppInfo *app_info;
progress_timeout (GtkWidget *assistant)
{
GtkWidget *progress;
- gint current_page;
+ int current_page;
gdouble value;
current_page = gtk_assistant_get_current_page (GTK_ASSISTANT (assistant));
selected_branch = branch;
}
-static gint
-nonlinear_assistant_forward_page (gint current_page, gpointer data)
+static int
+nonlinear_assistant_forward_page (int current_page, gpointer data)
{
switch (current_page)
{
}
}
-static gint
-looping_assistant_forward_page (gint current_page, gpointer data)
+static int
+looping_assistant_forward_page (int current_page, gpointer data)
{
switch (current_page)
{
main (int argc, gchar *argv[])
{
GtkWidget *window, *box, *button;
- gint i;
+ int i;
gboolean done = FALSE;
gtk_init ();
baseline_row_value_changed (GtkSpinButton *spin_button,
GtkGrid *grid)
{
- gint row = gtk_spin_button_get_value_as_int (spin_button);
+ int row = gtk_spin_button_get_value_as_int (spin_button);
gtk_grid_set_baseline_row (grid, row);
}
image_size_value_changed (GtkSpinButton *spin_button,
GtkImage *image)
{
- gint size = gtk_spin_button_get_value_as_int (spin_button);
+ int size = gtk_spin_button_get_value_as_int (spin_button);
gtk_image_set_pixel_size (GTK_IMAGE (image), size);
}
static void
-set_font_size (GtkWidget *widget, gint size)
+set_font_size (GtkWidget *widget, int size)
{
const gchar *class[3] = { "small-font", "medium-font", "large-font" };
GtkWidget *calendar = gtk_calendar_new ();
GtkWidget *button;
GtkWidget *frame, *label, *bbox;
- gint i;
+ int i;
struct {
const char *prop_name;
const char *label;
GtkIconView *iconview)
{
GtkCellArea *area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (iconview));
- gint value;
+ int value;
- value = (gint)gtk_spin_button_get_value (spin_button);
+ value = (int)gtk_spin_button_get_value (spin_button);
gtk_cell_area_box_set_spacing (GTK_CELL_AREA_BOX (area), value);
}
row_spacing_changed (GtkSpinButton *spin_button,
GtkIconView *iconview)
{
- gint value;
+ int value;
- value = (gint)gtk_spin_button_get_value (spin_button);
+ value = (int)gtk_spin_button_get_value (spin_button);
gtk_icon_view_set_row_spacing (iconview, value);
}
item_padding_changed (GtkSpinButton *spin_button,
GtkIconView *iconview)
{
- gint value;
+ int value;
- value = (gint)gtk_spin_button_get_value (spin_button);
+ value = (int)gtk_spin_button_get_value (spin_button);
gtk_icon_view_set_item_padding (iconview, value);
}
static gboolean
capital_animation (gpointer data)
{
- static gint insert_count = 0;
+ static int insert_count = 0;
GtkTreeModel *model = GTK_TREE_MODEL (data);
GtkTreePath *path;
GtkTreeIter iter, parent;
gpointer data)
{
GtkTreePath *path;
- gint *indices;
+ int *indices;
gboolean sensitive;
path = gtk_tree_model_get_path (tree_model, iter);
displayed_row_changed (GtkComboBox *combo,
GtkCellView *cell)
{
- gint row;
+ int row;
GtkTreePath *path;
row = gtk_combo_box_get_active (combo);
GtkTreeIter iter;
GtkCellArea *area;
gchar *text;
- gint i;
+ int i;
gboolean done = FALSE;
gtk_init ();
on_reorder (void)
{
GArray *new_contents;
- gint *shuffle_array;
- gint i;
+ int *shuffle_array;
+ int i;
shuffle_array = g_new (int, contents->len);
for (i = 0; i + 1 < contents->len; i++)
{
- gint pos = g_random_int_range (i, contents->len);
- gint tmp;
+ int pos = g_random_int_range (i, contents->len);
+ int tmp;
tmp = shuffle_array[i];
shuffle_array[i] = shuffle_array[pos];
static int n_animations = 0;
static int timer = 0;
-static gint
+static int
animation_timer (gpointer data)
{
switch (g_random_int_range (0, 3))
gpointer data)
{
GtkWidget *label = GTK_WIDGET (data);
- gint active;
+ int active;
active = gtk_combo_box_get_active (GTK_COMBO_BOX (combo));
gtk_label_set_ellipsize (GTK_LABEL (label), (PangoEllipsizeMode)active);
return ret;
}
-static gint timer_count = 0;
+static int timer_count = 0;
static const char *dynamic_completions[] = {
"GNOME",
"zombie"
};
-static gint
+static int
animation_timer (GtkEntryCompletion *completion)
{
GtkTreeIter iter;
- gint n_completions = G_N_ELEMENTS (dynamic_completions);
- gint n;
+ int n_completions = G_N_ELEMENTS (dynamic_completions);
+ int n;
static GtkListStore *old_store = NULL;
GtkListStore *store = GTK_LIST_STORE (gtk_entry_completion_get_model (completion));
#include <stdio.h>
static void
-clear_pressed (GtkEntry *entry, gint icon, gpointer data)
+clear_pressed (GtkEntry *entry, int icon, gpointer data)
{
if (icon == GTK_ENTRY_ICON_SECONDARY)
gtk_editable_set_text (GTK_EDITABLE (entry), "");
XSync (d, TRUE);
}
-gint
-main (gint argc, gchar *argv[])
+int
+main (int argc, gchar *argv[])
{
GdkDisplay *gdk_display;
GdkDisplay *extra_display;
static void
response_cb (GtkDialog *dialog,
- gint response_id,
+ int response_id,
gpointer data)
{
gboolean *done = data;
#define N_ITEMS 1000
static GtkFlowBox *the_flowbox = NULL;
-static gint items_type = SIMPLE_ITEMS;
+static int items_type = SIMPLE_ITEMS;
static void
populate_flowbox_simple (GtkFlowBox *flowbox)
{
GtkWidget *widget, *frame;
- gint i;
+ int i;
for (i = 0; i < N_ITEMS; i++)
{
populate_flowbox_focus (GtkFlowBox *flowbox)
{
GtkWidget *widget, *frame, *box;
- gint i;
+ int i;
gboolean sensitive;
for (i = 0; i < 200; i++)
populate_flowbox_buttons (GtkFlowBox *flowbox)
{
GtkWidget *widget;
- gint i;
+ int i;
for (i = 0; i < 50; i++)
{
populate_flowbox_wrappy (GtkFlowBox *flowbox)
{
GtkWidget *widget, *frame;
- gint i;
+ int i;
const gchar *strings[] = {
"These are", "some wrappy label", "texts", "of various", "lengths.",
populate_flowbox_images (GtkFlowBox *flowbox)
{
GtkWidget *widget, *image, *label;
- gint i;
+ int i;
for (i = 0; i < N_ITEMS; i++)
{
line_length_changed (GtkSpinButton *spin,
GtkFlowBox *flowbox)
{
- gint length = gtk_spin_button_get_value_as_int (spin);
+ int length = gtk_spin_button_get_value_as_int (spin);
gtk_flow_box_set_min_children_per_line (flowbox, length);
}
max_line_length_changed (GtkSpinButton *spin,
GtkFlowBox *flowbox)
{
- gint length = gtk_spin_button_get_value_as_int (spin);
+ int length = gtk_spin_button_get_value_as_int (spin);
gtk_flow_box_set_max_children_per_line (flowbox, length);
}
gpointer data)
{
GtkOrientation orientation = GPOINTER_TO_INT (data);
- gint state = gtk_spin_button_get_value_as_int (button);
+ int state = gtk_spin_button_get_value_as_int (button);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
gtk_flow_box_set_column_spacing (the_flowbox, state);
static gboolean
filter_func (GtkFlowBoxChild *child, gpointer user_data)
{
- gint index;
+ int index;
index = gtk_flow_box_child_get_index (child);
gtk_flow_box_set_filter_func (flowbox, NULL, NULL, NULL);
}
-static gint
+static int
sort_func (GtkFlowBoxChild *a,
GtkFlowBoxChild *b,
gpointer data)
{
FcConfig *config;
PangoFontMap *fontmap;
- gint i;
+ int i;
/* Create a custom font configuration by adding font files specified
* on the commandline to the default config.
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gchar **group_actions;
- gint i;
+ int i;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
group_actions = g_action_group_list_actions (group);
GtkWidget *viewport;
GtkWidget *grid;
GtkWidget *child;
- gint i;
+ int i;
window = gtk_window_new ();
gtk_window_set_title (GTK_WINDOW (window), "Scrolling");
static GtkWidget *
build_option_menu (const char *items[],
- gint num_items,
- gint history,
+ int num_items,
+ int history,
void (*func) (GtkWidget *widget, gpointer data),
gpointer data);
static GtkWidget *
build_option_menu (const char *items[],
- gint num_items,
- gint history,
+ int num_items,
+ int history,
void (*func)(GtkWidget *widget, gpointer data),
gpointer data)
{
GtkWidget *omenu;
- gint i;
+ int i;
omenu = gtk_combo_box_text_new ();
g_signal_connect (omenu, "changed",
{
GtkWidget *grid;
GtkWidget *group_widget = NULL;
- gint i, j;
+ int i, j;
grid = gtk_grid_new ();
}
static void
-dialog_response (GtkWidget *dialog, gint response_id, GtkLabel *label)
+dialog_response (GtkWidget *dialog, int response_id, GtkLabel *label)
{
const gchar *text;
static int
list_sort_cb (GtkListBoxRow *a, GtkListBoxRow *b, gpointer data)
{
- gint aa = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (a), "value"));
- gint bb = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (b), "value"));
+ int aa = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (a), "value"));
+ int bb = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (b), "value"));
return aa - bb;
}
static gboolean
list_filter_odd_cb (GtkListBoxRow *row, gpointer data)
{
- gint value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "value"));
+ int value = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (row), "value"));
return value % 2 == 0;
}
for (i = 0; i < 1000; i++)
{
- gint value = g_random_int_range (0, 10000);
+ int value = g_random_int_range (0, 10000);
label = gtk_label_new (g_strdup_printf ("Value %u", value));
gtk_list_box_insert (GTK_LIST_BOX (list), label, -1);
g_object_set_data (G_OBJECT (gtk_widget_get_parent (label)), "value", GINT_TO_POINTER (value));
}
static void
-scrolled_windows_remove (GtkWidget *dialog, gint response, GtkWidget *scrollwin)
+scrolled_windows_remove (GtkWidget *dialog, int response, GtkWidget *scrollwin)
{
if (response != GTK_RESPONSE_APPLY)
{
g_free (buffer);
}
-static gint
+static int
spin_button_time_output_func (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
return TRUE;
}
-static gint
+static int
spin_button_month_input_func (GtkSpinButton *spin_button,
gdouble *new_val)
{
- gint i;
+ int i;
static const char *month[12] = { "January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December" };
return TRUE;
}
-static gint
+static int
spin_button_month_output_func (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
gdouble value;
- gint i;
+ int i;
static const char *month[12] = { "January", "February", "March", "April",
"May", "June", "July", "August", "September",
"October", "November", "December" };
return TRUE;
}
-static gint
+static int
spin_button_hex_input_func (GtkSpinButton *spin_button,
gdouble *new_val)
{
return TRUE;
}
-static gint
+static int
spin_button_hex_output_func (GtkSpinButton *spin_button)
{
GtkAdjustment *adjustment;
if (fabs (val) < 1e-5)
sprintf (buf, "0x00");
else
- sprintf (buf, "0x%.2X", (gint) val);
+ sprintf (buf, "0x%.2X", (int) val);
if (strcmp (buf, gtk_editable_get_text (GTK_EDITABLE (spin_button))))
gtk_editable_set_text (GTK_EDITABLE (spin_button), buf);
cursor_model (void)
{
GtkListStore *store;
- gint i;
+ int i;
store = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i < G_N_ELEMENTS (cursor_names); i++)
{
GtkWidget *widget;
const gchar *name;
- gint i;
- const gint n = G_N_ELEMENTS (cursor_names);
+ int i;
+ const int n = G_N_ELEMENTS (cursor_names);
int button;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
{
#if defined(GDK_WINDOWING_X11) || defined (GDK_WINDOWING_WAYLAND)
const gchar *theme;
- gint size;
+ int size;
GdkDisplay *display;
GtkWidget *entry;
GtkWidget *spin;
spin = gtk_widget_get_next_sibling (entry);
theme = gtk_editable_get_text (GTK_EDITABLE (entry));
- size = (gint) gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin));
+ size = (int) gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin));
display = gtk_widget_get_display (widget);
#ifdef GDK_WINDOWING_X11
static GtkWidget *dialog_window = NULL;
static void
-dialog_response_cb (GtkWidget *widget, gint response, gpointer unused)
+dialog_response_cb (GtkWidget *widget, int response, gpointer unused)
{
GtkWidget *content_area;
GtkWidget *child;
else
{
GtkTreeModel *model = gtk_combo_box_get_model (GTK_COMBO_BOX (data->combo));
- gint i = 0;
+ int i = 0;
GtkTreeIter iter;
gboolean found = FALSE;
while (gtk_tree_model_iter_nth_child (model, &iter, NULL, i++))
GtkWidget *sample_notebook;
static void
-set_page_image (GtkNotebook *notebook, gint page_num, GdkPixbuf *pixbuf)
+set_page_image (GtkNotebook *notebook, int page_num, GdkPixbuf *pixbuf)
{
GtkWidget *page_widget;
GtkWidget *pixwid;
}
static void
-page_switch (GtkWidget *widget, gpointer *page, gint page_num)
+page_switch (GtkWidget *widget, gpointer *page, int page_num)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
- gint old_page_num = gtk_notebook_get_current_page (notebook);
+ int old_page_num = gtk_notebook_get_current_page (notebook);
if (page_num == old_page_num)
return;
}
static void
-create_pages (GtkNotebook *notebook, gint start, gint end)
+create_pages (GtkNotebook *notebook, int start, int end)
{
GtkWidget *child = NULL;
GtkWidget *button;
GtkWidget *label_box;
GtkWidget *menu_box;
GtkWidget *pixwid;
- gint i;
+ int i;
char buffer[32];
char accel_buffer[32];
gpointer data)
{
GtkNotebook *notebook;
- gint i, c;
+ int i, c;
enum {
STANDARD,
static void
get_ints (GtkWidget *window,
- gint *a,
- gint *b)
+ int *a,
+ int *b)
{
GtkWidget *spin1;
GtkWidget *spin2;
set_size_callback (GtkWidget *widget,
gpointer data)
{
- gint w, h;
+ int w, h;
get_ints (data, &w, &h);
set_default_size_callback (GtkWidget *widget,
gpointer data)
{
- gint w, h;
+ int w, h;
get_ints (data, &w, &h);
set_size_request_callback (GtkWidget *widget,
gpointer data)
{
- gint w, h;
+ int w, h;
get_ints (data, &w, &h);
progressbar_toggle_orientation (GtkWidget *widget, gpointer data)
{
ProgressData *pdata;
- gint i;
+ int i;
pdata = (ProgressData *) data;
ProgressData *pdata = data;
if (gtk_widget_is_drawable (widget))
{
- gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
+ int i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (pdata->pbar), i);
}
}
static void
native_response (GtkNativeDialog *self,
- gint response_id,
+ int response_id,
GtkWidget *label)
{
static int count = 0;
create_window (void)
{
GtkWidget *window, *vbox, *button;
- gint i;
+ int i;
window = gtk_window_new ();
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
GtkTreePath *path;
GtkTreeModel *model;
GtkTreeIter iter;
- gint col;
+ int col;
GtkTreePath *sel;
if (view == views->view1 && direction == GTK_DIR_DOWN)
}
static void
-add_n_items (GtkIconView *icon_list, gint n)
+add_n_items (GtkIconView *icon_list, int n)
{
- static gint count = NUMBER_OF_ITEMS;
+ static int count = NUMBER_OF_ITEMS;
GtkTreeIter iter;
GtkListStore *store;
GdkPixbuf *pixbuf;
gchar *str, *str2;
- gint i;
+ int i;
store = GTK_LIST_STORE (gtk_icon_view_get_model (icon_list));
pixbuf = gdk_pixbuf_new_from_file ("gnome-textfile.png", NULL);
return TRUE;
}
-gint
-main (gint argc, gchar **argv)
+int
+main (int argc, gchar **argv)
{
GtkWidget *paned, *tv;
GtkWidget *window, *icon_list, *scrolled_window;
GtkListStore *store;
GtkWidget *textview;
GdkContentFormats *targets;
- gint i;
+ int i;
window = gtk_window_new ();
gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
{
GtkListBoxRow parent_instance;
GtkWidget *label;
- gint sort_id;
+ int sort_id;
};
struct _RowClass
}
static GtkWidget *
-row_new (const gchar* text, gint sort_id) {
+row_new (const gchar* text, int sort_id) {
Row *row;
row = g_object_new (row_get_type (), NULL);
add_row_below (GtkButton *button, GtkWidget *child)
{
GtkWidget *revealer, *row, *list;
- gint index;
+ int index;
row = gtk_widget_get_parent (child);
index = gtk_list_box_row_get_index (GTK_LIST_BOX_ROW (row));
int main (int argc, char *argv[])
{
GtkWidget *window, *list, *sw, *row;
- gint i;
+ int i;
gchar *text;
gboolean done = FALSE;
{
GtkWidget *window, *list, *sw, *row;
GtkWidget *hbox, *vbox, *combo, *button;
- gint i;
+ int i;
gchar *text;
GtkCssProvider *provider;
GtkWidget *row_content;
GtkListBoxRow *row;
- gint i;
+ int i;
gchar *text, *text2;
window = gtk_application_window_new (GTK_APPLICATION (app));
if (ask_question)
{
- gint choice = g_mount_operation_get_choice (op);
+ int choice = g_mount_operation_get_choice (op);
g_print ("User chose: %d\n", choice);
}
else
static GtkNotebook*
window_creation_function (GtkNotebook *source_notebook,
GtkWidget *child,
- gint x,
- gint y,
+ int x,
+ int y,
gpointer data)
{
GtkWidget *window, *notebook;
GtkPositionType pos)
{
GtkWidget *notebook, *title, *page;
- gint count = 0;
+ int count = 0;
notebook = gtk_notebook_new ();
g_signal_connect (notebook, "create-window",
g_main_context_wakeup (NULL);
}
-gint
-main (gint argc, gchar *argv[])
+int
+main (int argc, gchar *argv[])
{
GtkWidget *window, *grid;
gboolean done = FALSE;
int
main (int argc, char *argv[])
{
- gint i;
+ int i;
gtk_init ();
load_types ();
#include <gtk/gtk.h>
-gint
-main (gint argc,
+int
+main (int argc,
gchar ** argv)
{
GtkWidget *window, *revealer, *box, *widget, *entry;
static void
populate_list (GtkListBox *list)
{
- gint i;
+ int i;
gchar *text;
GtkWidget *row, *label;
- gint n;
+ int n;
GtkWidget *child;
for (child = gtk_widget_get_first_child (GTK_WIDGET (list)), n = 0;
gdouble value;
value = gtk_spin_button_get_value (spin_button);
- gtk_scrolled_window_set_min_content_width (swindow, (gint)value);
+ gtk_scrolled_window_set_min_content_width (swindow, (int)value);
}
static void
gdouble value;
value = gtk_spin_button_get_value (spin_button);
- gtk_scrolled_window_set_min_content_height (swindow, (gint)value);
+ gtk_scrolled_window_set_min_content_height (swindow, (int)value);
}
static void
}
static void
-add_row (GtkWidget *list, gint i)
+add_row (GtkWidget *list, int i)
{
GtkWidget *row;
GtkWidget *label;
GtkWidget *window;
GtkWidget *list;
GtkWidget *button;
- gint i;
+ int i;
GSimpleActionGroup *group;
GSimpleAction *action;
#include "config.h"
#include <gtk/gtk.h>
-static gint num_windows = 0;
+static int num_windows = 0;
static gboolean done = FALSE;
{
const gchar *seq[] = { "1", "2", "3" };
const gchar *vis;
- gint i;
+ int i;
vis = gtk_stack_get_visible_child_name (GTK_STACK (stack));
{
const gchar *seq[] = { "1", "2", "3" };
const gchar *vis;
- gint i;
+ int i;
vis = gtk_stack_get_visible_child_name (GTK_STACK (stack));
gtk_widget_set_sensitive (button, g_strcmp0 (vis, "3") != 0);
}
-gint
-main (gint argc,
+int
+main (int argc,
gchar ** argv)
{
GtkWidget *window, *box, *button, *hbox, *combo, *layout;
static void
do_select (gpointer funcs_data,
- gint selection_insert,
- gint selection_bound)
+ int selection_insert,
+ int selection_bound)
{
Text *text = funcs_data;
static gboolean
query_tooltip_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
static gboolean
query_tooltip_text_view_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
if (keyboard_tip)
{
- gint offset;
+ int offset;
g_object_get (buffer, "cursor-position", &offset, NULL);
gtk_text_buffer_get_iter_at_offset (buffer, &iter, offset);
}
else
{
- gint bx, by, trailing;
+ int bx, by, trailing;
gtk_text_view_window_to_buffer_coords (text_view, GTK_TEXT_WINDOW_TEXT,
x, y, &bx, &by);
static gboolean
query_tooltip_tree_view_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
static struct Rectangle
{
- gint x;
- gint y;
+ int x;
+ int y;
gfloat r;
gfloat g;
gfloat b;
static gboolean
query_tooltip_drawing_area_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
{
- gint i;
+ int i;
if (keyboard_tip)
return FALSE;
int height,
gpointer data)
{
- gint i;
+ int i;
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
static gboolean
query_tooltip_label_cb (GtkWidget *widget,
- gint x,
- gint y,
+ int x,
+ int y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
GtkListStore parent;
GtkTreeView *view;
GList *columns;
- gint stamp;
+ int stamp;
};
struct _ViewColumnModelClass
model->stamp = g_random_int ();
}
-static gint
+static int
view_column_model_get_n_columns (GtkTreeModel *tree_model)
{
return 2;
static GType
view_column_model_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ int index)
{
switch (index)
{
{
ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
GList *list;
- gint i;
+ int i;
g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE);
ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
GtkTreePath *retval;
GList *list;
- gint i = 0;
+ int i = 0;
g_return_val_if_fail (iter->stamp == view_model->stamp, NULL);
static void
view_column_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
#ifndef G_DISABLE_CHECKS
return FALSE;
}
-static gint
+static int
view_column_model_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
return g_list_length (((ViewColumnModel *)tree_model)->columns);
}
-static gint
+static int
view_column_model_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
ViewColumnModel *view_model = (ViewColumnModel *)tree_model;
update_columns (GtkTreeView *view, ViewColumnModel *view_model)
{
GList *old_columns = view_model->columns;
- gint old_length, length;
+ int old_length, length;
GList *a, *b;
view_model->columns = gtk_tree_view_get_columns (view_model->view);
if (length != old_length)
{
GtkTreePath *path;
- gint i = 0;
+ int i = 0;
/* where are they different */
for (a = old_columns, b = view_model->columns; a && b; a = a->next, b = b->next)
}
else
{
- gint i;
- gint m = 0, n = 1;
- gint *new_order;
+ int i;
+ int m = 0, n = 1;
+ int *new_order;
GtkTreePath *path;
new_order = g_new (int, length);
static void
add_clicked (GtkWidget *button, gpointer data)
{
- static gint i = 0;
+ static int i = 0;
GtkTreeIter iter;
GtkTreeViewColumn *column;
{
gchar *label;
GtkTreeViewColumn *column;
- gint before = -1;
+ int before = -1;
gtk_tree_model_get (GTK_TREE_MODEL (left_tree_model),
src_iter, 0, &label, 1, &column, -1);
{
GtkTreeViewColumn *column;
gchar *label;
- gint before = -1;
+ int before = -1;
gtk_tree_model_get (src, src_iter, 0, &label, 1, &column, -1);
GtkWidget *swindow;
GtkTreeModel *sample_model;
GdkContentFormats *targets;
- gint i;
+ int i;
gboolean done = FALSE;
gtk_init ();
const gchar *string;
gboolean is_editable;
gboolean is_sensitive;
- gint progress;
+ int progress;
} ListEntry;
enum {
{
GtkTreeStore *model;
GtkTreeIter iter;
- gint i;
+ int i;
model = gtk_tree_store_new (NUM_COLUMNS,
G_TYPE_STRING,
};
static void
-create_control (GtkWidget *box, gint number, gint cntl, CallbackData *data)
+create_control (GtkWidget *box, int number, int cntl, CallbackData *data)
{
GtkWidget *checkbutton;
GCallback callback = NULL;
g_main_context_wakeup (NULL);
}
-gint
-main (gint argc, gchar **argv)
+int
+main (int argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
static void
initialize_model (void)
{
- gint i;
+ int i;
GtkTreeIter iter;
model = (GtkTreeModel *) gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING);
static void
futz_row (void)
{
- gint i;
+ int i;
GtkTreePath *path;
GtkTreeIter iter;
GtkTreeIter iter2;
static gboolean
futz (void)
{
- gint i;
+ int i;
for (i = 0; i < 15; i++)
futz_row ();
GtkTreeIter *iter,
gpointer data)
{
- gint size;
+ int size;
GtkTreePath *path;
path = gtk_tree_model_get_path (model, iter);
GtkWidget *tree_view;
GtkTreeModel *model;
GtkCellRenderer *renderer;
- gint col_offset;
+ int col_offset;
GtkTreeViewColumn *column;
gboolean done = FALSE;
#include <gtk/gtk.h>
-static gint repeats = 2;
-static gint max_size = 8;
+static int repeats = 2;
+static int max_size = 8;
static GOptionEntry entries[] = {
{ "repeats", 'r', 0, G_OPTION_ARG_INT, &repeats, "Average over N repetitions", "N" },
typedef void (ClearFunc)(GtkTreeModel *model);
typedef void (InsertFunc)(GtkTreeModel *model,
- gint items,
- gint i);
+ int items,
+ int i);
static void
list_store_append (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkListStore *store = GTK_LIST_STORE (model);
GtkTreeIter iter;
static void
list_store_prepend (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkListStore *store = GTK_LIST_STORE (model);
GtkTreeIter iter;
static void
list_store_insert (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkListStore *store = GTK_LIST_STORE (model);
GtkTreeIter iter;
gchar *text;
- gint n;
+ int n;
text = g_strdup_printf ("row %d", i);
n = g_random_int_range (0, i + 1);
g_free (text);
}
-static gint
+static int
compare (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer data)
{
gchar *str_a, *str_b;
- gint result;
+ int result;
gtk_tree_model_get (model, a, 1, &str_a, -1);
gtk_tree_model_get (model, b, 1, &str_b, -1);
static void
tree_store_append (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
static void
tree_store_prepend (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
static void
tree_store_insert_flat (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
gchar *text;
- gint n;
+ int n;
text = g_strdup_printf ("row %d", i);
n = g_random_int_range (0, i + 1);
}
typedef struct {
- gint i;
- gint n;
+ int i;
+ int n;
gboolean found;
GtkTreeIter iter;
} FindData;
static void
tree_store_insert_deep (GtkTreeModel *model,
- gint items,
- gint i)
+ int items,
+ int i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
ClearFunc *clear,
InsertFunc *insert)
{
- gint i, k, d, items;
+ int i, k, d, items;
GTimer *timer;
gdouble elapsed;
int memused;
static gboolean
clicked_icon (GtkTreeView *tv,
- gint x,
- gint y,
+ int x,
+ int y,
GtkTreePath **path)
{
GtkTreeViewColumn *col;
- gint cell_x, cell_y;
- gint cell_pos, cell_width;
+ int cell_x, cell_y;
+ int cell_pos, cell_width;
GList *cells, *l;
- gint depth;
- gint level_indentation;
- gint expander_size;
- gint indent;
+ int depth;
+ int level_indentation;
+ int expander_size;
+ int indent;
if (gtk_tree_view_get_path_at_pos (tv, x, y, path, &col, &cell_x, &cell_y))
{
GtkTreeView *tv)
{
GtkTreePath *path;
- gint tx, ty;
+ int tx, ty;
gtk_tree_view_convert_widget_to_tree_coords (tv, x, y, &tx, &ty);
const gchar *word_2;
const gchar *word_3;
const gchar *word_4;
- gint number_1;
+ int number_1;
};
static ListSort data[] =
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter iter;
- gint i;
+ int i;
GtkWidget *entry, *button;
GtkWidget *window2, *vbox2, *scrolled_window2, *tree_view2;
/* 12 iters now, 12 later... */
for (i = 0; data[i].word_1 != NULL; i++)
{
- gint k;
+ int k;
GtkTreeIter child_iter;
for (i = 0; data[i].word_1 != NULL; i++)
{
- gint k;
+ int k;
gtk_tree_store_prepend (GTK_TREE_STORE (model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (model), &iter,
{
GObject parent;
- gint stamp;
+ int stamp;
};
struct _GtkTreeModelTypesClass
GObjectClass parent_class;
guint (* get_flags) (GtkTreeModel *tree_model);
- gint (* get_n_columns) (GtkTreeModel *tree_model);
+ int (* get_n_columns) (GtkTreeModel *tree_model);
GType (* get_column_type) (GtkTreeModel *tree_model,
- gint index);
+ int index);
gboolean (* get_iter) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path);
GtkTreeIter *iter);
void (* get_value) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
gboolean (* iter_next) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreeIter *parent);
gboolean (* iter_has_child) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
- gint (* iter_n_children) (GtkTreeModel *tree_model,
+ int (* iter_n_children) (GtkTreeModel *tree_model,
GtkTreeIter *iter);
gboolean (* iter_nth_child) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
gboolean (* iter_parent) (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
{
GtkListStore *store;
GtkTreeIter iter;
- gint i;
+ int i;
GType *t;
t = get_model_types ();
{
GType* children;
guint n_children = 0;
- gint i;
+ int i;
GtkTreeIter iter;
gchar *str;
create_tree_model (void)
{
GtkTreeStore *store;
- gint i;
+ int i;
GType *t;
/* Make the tree more interesting */
model_selected (GtkComboBox *combo_box, gpointer data)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (data);
- gint hist;
+ int hist;
hist = gtk_combo_box_get_active (combo_box);
columns_selected (GtkComboBox *combo_box, gpointer data)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (data);
- gint hist;
+ int hist;
hist = gtk_combo_box_get_active (combo_box);
GtkWidget *combo_box;
GtkTreeModel *model;
GdkContentFormats *targets;
- gint i;
+ int i;
gboolean done = FALSE;
gtk_init ();
static void gtk_tree_model_types_init (GtkTreeModelTypes *model_types);
static void gtk_tree_model_types_tree_model_init (GtkTreeModelIface *iface);
-static gint gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model);
+static int gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model);
static GType gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
- gint index);
+ int index);
static GtkTreePath *gtk_real_model_types_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static void gtk_real_model_types_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value);
static gboolean gtk_real_model_types_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter);
GtkTreeIter *parent);
static gboolean gtk_real_model_types_iter_has_child (GtkTreeModel *tree_model,
GtkTreeIter *iter);
-static gint gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
+static int gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter);
static gboolean gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n);
+ int n);
static gboolean gtk_real_model_types_iter_parent (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *child);
G_TYPE_STRING /* type name */
};
-static gint
+static int
gtk_real_model_types_get_n_columns (GtkTreeModel *tree_model)
{
return G_N_ELEMENTS (column_types);
static GType
gtk_real_model_types_get_column_type (GtkTreeModel *tree_model,
- gint index)
+ int index)
{
g_return_val_if_fail (index < G_N_ELEMENTS (column_types), G_TYPE_INVALID);
while (parent != G_TYPE_INVALID)
{
GType* children = g_type_children (parent, NULL);
- gint i = 0;
+ int i = 0;
if (!children || children[0] == G_TYPE_INVALID)
{
static void
gtk_real_model_types_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
- gint column,
+ int column,
GValue *value)
{
GType type;
else
{
GType* children = g_type_children (parent, NULL);
- gint i = 0;
+ int i = 0;
g_assert (children != NULL);
}
}
-static gint
+static int
gtk_real_model_types_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
gtk_real_model_types_iter_nth_child (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent,
- gint n)
+ int n)
{
if (parent == NULL)
{
static void
treestore_torture_recurse (GtkTreeStore *store,
GtkTreeIter *root,
- gint depth)
+ int depth)
{
GtkTreeModel *model;
- gint i;
+ int i;
GtkTreeIter iter;
model = GTK_TREE_MODEL (store);
/* Make sure list store mutations don't crash anything */
GtkListStore *store;
GtkTreeModel *model;
- gint i;
+ int i;
GtkTreeIter iter;
store = gtk_list_store_new (1, G_TYPE_INT);
const gchar *description;
const gchar *fine_print;
const gchar *fine_print_color;
- gint progress;
+ int progress;
TreeEntry *entries;
};
TreeEntry *entries)
{
GtkTreeIter iter;
- gint i;
+ int i;
for (i = 0; entries[i].info != NULL; i++)
{
create_model (void)
{
GtkTreeStore *model;
- gint i;
+ int i;
model = gtk_tree_store_new (NUM_COLUMNS,
G_TYPE_STRING,
g_main_context_wakeup (NULL);
}
-gint
-main (gint argc, gchar **argv)
+int
+main (int argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
static void
response_cb (GtkDialog *dialog,
- gint arg1,
+ int arg1,
gpointer user_data)
{
gtk_window_destroy (GTK_WINDOW (dialog));
{
GtkWidget *dialog;
GtkWidget *label;
- gint width_chars, max_width_chars, default_width, default_height;
+ int width_chars, max_width_chars, default_width, default_height;
gboolean resizable;
width_chars = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (width_chars_spin));
#include <string.h>
GtkTreeStore *base_model;
-static gint node_count = 0;
+static int node_count = 0;
static void
selection_changed (GtkTreeSelection *selection,
static void
node_set (GtkTreeIter *iter)
{
- gint n;
+ int n;
gchar *str;
str = g_strdup_printf ("Row (<span color=\"red\">%d</span>)", node_count++);
}
static void
-make_window (gint view_type)
+make_window (int view_type)
{
GtkWidget *window;
GtkWidget *vbox;
adjust_clock_for_phase (gint64 frame_clock_time,
gint64 presentation_time)
{
- static gint count = 0;
+ static int count = 0;
static gint64 previous_frame_clock_time;
static gint64 previous_presentation_time;
gint64 phase = presentation_time - frame_clock_time;
}
}
-static gint
+static int
compare_attr (gconstpointer a, gconstpointer b)
{
const AtkAttribute *aattr = a;
static void
dump_text_attributes (GString *string,
- gint depth,
+ int depth,
const gchar *name,
AtkAttributeSet *attributes)
{
GString *string)
{
gchar *text;
- gint i, start, end;
+ int i, start, end;
g_string_append_printf (string, "%*s<AtkText>\n", depth, "");
guint depth,
GString *string)
{
- gint width, height;
+ int width, height;
g_string_append_printf (string, "%*s<AtkImage>\n", depth, "");
guint depth,
GString *string)
{
- gint i;
+ int i;
g_string_append_printf (string, "%*s<AtkAction>\n", depth, "");
GString *string)
{
guint n_selections, n_counted_selections;
- gint i;
+ int i;
g_string_append_printf (string, "%*s<AtkSelection>\n", depth, "");
guint depth,
GString *string)
{
- gint i;
+ int i;
g_string_append_printf (string, "%*s<AtkHyperlink>\n", depth, "");
g_string_append_printf (string, "%*sstart index: %d\n", depth, "", atk_hyperlink_get_start_index (link));
guint depth,
GString *string)
{
- gint i;
+ int i;
AtkHyperlink *link;
g_string_append_printf (string, "%*s<AtkHypertext>\n", depth, "");
guint depth,
GString *string)
{
- gint i;
+ int i;
g_string_append_printf (string, "%*s<AtkStreamableContent>\n", depth, "");
guint depth,
GString *string)
{
- gint *selected;
- gint n_selected;
- gint i, j;
+ int *selected;
+ int n_selected;
+ int i, j;
AtkObject *obj;
const gchar *desc;
guint depth,
GString *string)
{
- gint i;
+ int i;
AtkObject *obj;
GPtrArray *cells;
- gint row = -1, column = -1;
+ int row = -1, column = -1;
g_string_append_printf (string, "%*s<AtkTableCell>\n", depth, "");
}
typedef struct {
- gint count;
- gint index;
- gint n_children;
+ int count;
+ int index;
+ int n_children;
gpointer parent;
} SignalData;
static void
remove_child (STATE *state,
- gint i)
+ int i)
{
GtkWidget *child;
}
static gboolean
-do_create_child (STATE *state, gint i)
+do_create_child (STATE *state, int i)
{
if (GTK_IS_ENTRY (state->widget))
{
SignalData remove_data;
SignalData parent_data[3] = { { 0, }, };
STATE state;
- gint i, j;
- gint step_children;
+ int i, j;
+ int step_children;
state.widget = widget;
accessible = gtk_widget_get_accessible (widget);
if (states)
{
- gint i;
+ int i;
for (i = 0; states[i]; i++)
{
do_action (GtkBuilder *builder, const gchar *action, GString *string)
{
gchar **parts;
- gint len;
- gint i;
+ int len;
+ int i;
parts = g_strsplit (action, " ", 0);
len = g_strv_length (parts);
GError *error;
gchar *contents;
gchar **actions;
- gint i, len;
+ int i, len;
builder = gtk_builder_new ();
error = NULL;
AtkText *atk_text;
const gchar *text = "Text goes here";
gchar *ret;
- gint count;
+ int count;
gunichar c;
atk_text = ATK_TEXT (gtk_widget_get_accessible (widget));
}
typedef struct {
- gint count;
- gint position;
- gint length;
+ int count;
+ int position;
+ int length;
} SignalData;
static void
-text_deleted (AtkText *atk_text, gint position, gint length, SignalData *data)
+text_deleted (AtkText *atk_text, int position, int length, SignalData *data)
{
data->count++;
data->position = position;
}
static void
-text_inserted (AtkText *atk_text, gint position, gint length, SignalData *data)
+text_inserted (AtkText *atk_text, int position, int length, SignalData *data)
{
data->count++;
data->position = position;
}
typedef struct {
- gint gravity;
- gint offset;
+ int gravity;
+ int offset;
AtkTextBoundary boundary;
- gint start;
- gint end;
+ int start;
+ int end;
const gchar *word;
} Word;
}
static const gchar *
-gravity (gint g)
+gravity (int g)
{
if (g < 0) return "before";
else if (g > 0) return "after";
show_text_attributes (PangoLayout *l)
{
const PangoLogAttr *attr;
- gint n_attrs;
+ int n_attrs;
const gchar *s;
gchar e;
const gchar *p;
- gint i;
+ int i;
const gchar *text;
GSList *lines, *li;
glong so, eo;
{ 1, 20, ATK_TEXT_BOUNDARY_LINE_END, 20, 20, "" },
{ 0, -1, }
};
- gint start, end;
+ int start, end;
gchar *word;
- gint i;
+ int i;
atk_text = ATK_TEXT (gtk_widget_get_accessible (widget));
#ifdef DUMP_RESULTS
for (i = -1; i <= 1; i++)
{
- gint j, k;
+ int j, k;
for (j = ATK_TEXT_BOUNDARY_CHAR; j <= ATK_TEXT_BOUNDARY_LINE_END; j++)
for (k = 0; k <= strlen (text); k++)
{
static void
select_region (GtkWidget *widget,
- gint start,
- gint end)
+ int start,
+ int end)
{
if (GTK_IS_EDITABLE (widget))
gtk_editable_select_region (GTK_EDITABLE (widget), start, end);
}
typedef struct {
- gint count;
- gint position;
- gint bound;
+ int count;
+ int position;
+ int bound;
} SelectionData;
static void
-caret_moved_cb (AtkText *text, gint position, SelectionData *data)
+caret_moved_cb (AtkText *text, int position, SelectionData *data)
{
data->count++;
data->position = position;
{
AtkText *atk_text;
const gchar *text = "Bla bla bla";
- gint n;
+ int n;
gchar *ret;
- gint start, end;
+ int start, end;
SelectionData data1;
SelectionData data2;
walk_accessible_tree (AtkObject *accessible,
gpointer data)
{
- gint *count = data;
- gint i;
+ int *count = data;
+ int i;
(*count)++;
GtkTreeView *tv;
GtkListStore *store;
GtkTreeIter iter;
- gint i;
+ int i;
tv = (GtkTreeView *)gtk_builder_get_object (builder, "treeview1");
store = (GtkListStore *)gtk_tree_view_get_model (tv);
gdouble elapsed;
GtkWidget *window;
GError *error = NULL;
- gint count_before;
- gint count_after;
+ int count_before;
+ int count_after;
builder = gtk_builder_new ();
gtk_builder_add_from_string (builder, list_ui, -1, &error);
GtkTreeView *tv;
GtkTreeStore *store;
GtkTreeIter iter;
- gint i;
+ int i;
tv = (GtkTreeView *)gtk_builder_get_object (builder, "treeview1");
store = (GtkTreeStore *)gtk_tree_view_get_model (tv);
gdouble elapsed;
GtkWidget *window;
GError *error = NULL;
- gint count_before;
- gint count_after;
+ int count_before;
+ int count_after;
builder = gtk_builder_new ();
gtk_builder_add_from_string (builder, tree_ui, -1, &error);
}
typedef struct {
- gint count;
+ int count;
AtkObject *descendant;
} SignalData;
static void
set_value (GtkWidget *widget,
- gint value)
+ int value)
{
if (GTK_IS_LEVEL_BAR (widget))
gtk_level_bar_set_value (GTK_LEVEL_BAR (widget), value);
typedef struct
{
- gint count;
+ int count;
gchar *last_name;
} NotifyData;
if (GDK_IS_X11_DISPLAY (display))
{
const char *encoding;
- gint format;
+ int format;
const guchar *text;
- gint length;
+ int length;
gchar **list;
- gint n;
+ int n;
encoding = g_intern_string ("UTF8_STRING");
format = 8;
{ GDK_KEY_MonBrightnessUp, "MonBrightnessUp", NULL },
{ 0, NULL }
};
- gint i;
+ int i;
for (i = 0; tests[i].keyval != 0; i++)
{
gboolean ignore_alpha)
{
guchar *expected_data, *test_data;
- gint width, height;
- gint x, y;
+ int width, height;
+ int x, y;
g_assert_cmpint (gdk_texture_get_width (expected), ==, gdk_texture_get_width (test));
g_assert_cmpint (gdk_texture_get_height (expected), ==, gdk_texture_get_height (test));
g_object_unref (a);
}
-static gint changed_count;
-static gint value_changed_count;
+static int changed_count;
+static int value_changed_count;
static void
changed_cb (GtkAdjustment *a)
{
GtkBuilder *builder;
GError *error;
- gint ret;
+ int ret;
GObject *obj;
const gchar *objects[2] = {"mainbox", NULL};
const gchar *objects2[3] = {"mainbox", "window2", NULL};
#include <gtk/gtk.h>
-static gint serial = 0;
+static int serial = 0;
typedef struct {
- gint serial;
- gint count;
- gint start;
- gint end;
+ int serial;
+ int count;
+ int start;
+ int end;
gchar *text;
gchar *new_text;
- gint position;
- gint length;
+ int position;
+ int length;
} EntryData;
static void
static void
insert_text (GtkEditable *editable,
const gchar *new_text,
- gint new_text_length,
- gint *position,
+ int new_text_length,
+ int *position,
EntryData *data)
{
data->serial = serial++;
static void
delete_text (GtkEditable *editable,
- gint start_pos,
- gint end_pos,
+ int start_pos,
+ int end_pos,
EntryData *data)
{
data->serial = serial++;
test_insert (void)
{
GtkWidget *entry;
- gint pos;
+ int pos;
EntryData data1;
EntryData data2;
EntryData data3;
test_delete (void)
{
GtkWidget *entry;
- gint pos;
+ int pos;
EntryData data1;
EntryData data2;
EntryData data3;
GtkTreeIter *iter,
gpointer data)
{
- gint number;
+ int number;
gboolean hide_negative_numbers;
gtk_tree_model_get (model, iter, 1, &number, -1);
}
-static gint
+static int
specific_sort_filter_remove_node_compare_func (GtkTreeModel *model,
GtkTreeIter *iter1,
GtkTreeIter *iter2,
typedef struct {
GtkWidget *widget;
- gint x;
- gint y;
+ int x;
+ int y;
guint state;
guint pressed : 1;
} PointState;
} GestureData;
static void
-press_cb (GtkGesture *g, gint n_press, gdouble x, gdouble y, gpointer data)
+press_cb (GtkGesture *g, int n_press, gdouble x, gdouble y, gpointer data)
{
GtkEventController *c = GTK_EVENT_CONTROLLER (g);
GdkEventSequence *sequence;
{
GtkGrid *g;
GtkWidget *child, *sibling, *z, *A, *B;
- gint left, top, width, height;
+ int left, top, width, height;
g = (GtkGrid *)gtk_grid_new ();
static gboolean
check_iter (GtkTreeModelRefCount *ref_model,
GtkTreeIter *iter,
- gint expected_ref_count,
+ int expected_ref_count,
gboolean may_assert)
{
NodeInfo *info;
gboolean
gtk_tree_model_ref_count_check_level (GtkTreeModelRefCount *ref_model,
GtkTreeIter *parent,
- gint expected_ref_count,
+ int expected_ref_count,
gboolean recurse,
gboolean may_assert)
{
gboolean
gtk_tree_model_ref_count_check_node (GtkTreeModelRefCount *ref_model,
GtkTreeIter *iter,
- gint expected_ref_count,
+ int expected_ref_count,
gboolean may_assert)
{
return check_iter (ref_model, iter, expected_ref_count, may_assert);
void gtk_tree_model_ref_count_dump (GtkTreeModelRefCount *ref_model);
gboolean gtk_tree_model_ref_count_check_level (GtkTreeModelRefCount *ref_model,
GtkTreeIter *parent,
- gint expected_ref_count,
+ int expected_ref_count,
gboolean recurse,
gboolean may_assert);
gboolean gtk_tree_model_ref_count_check_node (GtkTreeModelRefCount *ref_model,
GtkTreeIter *iter,
- gint expected_ref_count,
+ int expected_ref_count,
gboolean may_assert);
/* A couple of helpers for the tests. Since this model will never be used
static inline void
assert_entire_model_referenced (GtkTreeModelRefCount *ref_model,
- gint ref_count)
+ int ref_count)
{
gtk_tree_model_ref_count_check_level (ref_model, NULL, ref_count, TRUE, TRUE);
}
static inline void
assert_not_entire_model_referenced (GtkTreeModelRefCount *ref_model,
- gint ref_count)
+ int ref_count)
{
g_assert_cmpint (gtk_tree_model_ref_count_check_level (ref_model, NULL,
ref_count,
static inline void
assert_root_level_referenced (GtkTreeModelRefCount *ref_model,
- gint ref_count)
+ int ref_count)
{
gtk_tree_model_ref_count_check_level (ref_model, NULL, ref_count,
FALSE, TRUE);
static inline void
assert_level_referenced (GtkTreeModelRefCount *ref_model,
- gint ref_count,
+ int ref_count,
GtkTreeIter *iter)
{
gtk_tree_model_ref_count_check_level (ref_model, iter, ref_count,
static inline void
assert_node_ref_count (GtkTreeModelRefCount *ref_model,
GtkTreeIter *iter,
- gint ref_count)
+ int ref_count)
{
gtk_tree_model_ref_count_check_node (ref_model, iter, ref_count, TRUE);
}
static void
assert_icon_lookup_size (const char *icon_name,
- gint size,
+ int size,
GtkTextDirection direction,
GtkIconLookupFlags flags,
gboolean fallbacks,
const char *filename,
- gint pixbuf_size)
+ int pixbuf_size)
{
GtkIconPaintable *info;
GFile *file;
static void
assert_icon_lookup (const char *icon_name,
- gint size,
+ int size,
GtkTextDirection direction,
GtkIconLookupFlags flags,
gboolean fallbacks,
static void
assert_icon_lookup_fails (const char *icon_name,
- gint size,
+ int size,
GtkTextDirection direction,
GtkIconLookupFlags flags)
{
static void
assert_lookup_order (const char *icon_name,
- gint size,
+ int size,
GtkTextDirection direction,
GtkIconLookupFlags flags,
gboolean fallbacks,
static void
test_nonsquare_symbolic (void)
{
- gint width, height, size;
+ int width, height, size;
GtkIconTheme *icon_theme;
GtkIconPaintable *info;
GFile *file;
#include <gtk/gtk.h>
-static gint
+static int
sort_list (GtkListBoxRow *row1,
GtkListBoxRow *row2,
gpointer data)
{
GtkWidget *label1, *label2;
- gint n1, n2;
- gint *count = data;
+ int n1, n2;
+ int *count = data;
(*count)++;
GtkListBox *list;
GtkListBoxRow *row;
GtkWidget *label;
- gint i, r;
+ int i, r;
gchar *s;
- gint count;
+ int count;
list = GTK_LIST_BOX (gtk_list_box_new ());
g_object_ref_sink (list);
GtkListBoxRow *row,
gpointer data)
{
- gint *i = data;
+ int *i = data;
(*i)++;
GtkListBox *list;
GtkListBoxRow *row, *row2;
GtkWidget *label;
- gint i;
+ int i;
gchar *s;
- gint count;
- gint index;
+ int count;
+ int index;
list = GTK_LIST_BOX (gtk_list_box_new ());
g_object_ref_sink (list);
static void
on_selected_rows_changed (GtkListBox *box, gpointer data)
{
- gint *i = data;
+ int *i = data;
(*i)++;
}
GList *l;
GtkListBoxRow *row, *row2;
GtkWidget *label;
- gint i;
+ int i;
gchar *s;
- gint count;
+ int count;
list = GTK_LIST_BOX (gtk_list_box_new ());
g_object_ref_sink (list);
filter_func (GtkListBoxRow *row,
gpointer data)
{
- gint *count = data;
+ int *count = data;
GtkWidget *child;
- gint i;
+ int i;
(*count)++;
static void
check_filtered (GtkListBox *list)
{
- gint count;
+ int count;
GtkWidget *row;
count = 0;
{
GtkListBox *list;
GtkListBoxRow *row;
- gint i;
+ int i;
gchar *s;
GtkWidget *label;
- gint count;
+ int count;
list = GTK_LIST_BOX (gtk_list_box_new ());
g_object_ref_sink (list);
gpointer data)
{
GtkWidget *child;
- gint i;
- gint *count = data;
+ int i;
+ int *count = data;
GtkWidget *header;
gchar *s;
static void
check_headers (GtkListBox *list)
{
- gint count;
+ int count;
GtkWidget *row;
count = 0;
{
GtkListBox *list;
GtkListBoxRow *row;
- gint i;
+ int i;
gchar *s;
GtkWidget *label;
- gint count;
+ int count;
list = GTK_LIST_BOX (gtk_list_box_new ());
g_object_ref_sink (list);
static void
check_model (ListStore *fixture,
- gint *new_order,
- gint skip)
+ int *new_order,
+ int skip)
{
int i;
GtkTreePath *path;
typedef struct
{
const gchar *name;
- gint count;
+ int count;
} NotifyData;
static void
if (G_TYPE_IS_ENUM (pspec->value_type))
{
GEnumClass *class;
- gint i;
+ int i;
NotifyData data;
gulong id;
- gint first;
- gint value;
- gint current_count;
+ int first;
+ int value;
+ int current_count;
class = g_type_class_ref (pspec->value_type);
else if (G_TYPE_IS_FLAGS (pspec->value_type))
{
GFlagsClass *class;
- gint i;
+ int i;
NotifyData data;
gulong id;
guint value;
- gint current_count;
+ int current_count;
class = g_type_class_ref (pspec->value_type);
else if (pspec->value_type == G_TYPE_INT)
{
GParamSpecInt *p = G_PARAM_SPEC_INT (pspec);
- gint i;
+ int i;
NotifyData data;
gulong id;
- gint value;
- gint current_count;
+ int value;
+ int current_count;
data.name = pspec->name;
data.count = 0;
NotifyData data;
gulong id;
guint value;
- gint current_count;
+ int current_count;
guint minimum, maximum;
if (G_IS_PARAM_SPEC_UINT (pspec))
gulong id;
gdouble value;
gdouble new_value;
- gint current_count;
+ int current_count;
gdouble delta;
data.name = pspec->name;
gulong id;
gfloat value;
gfloat new_value;
- gint current_count;
+ int current_count;
data.name = pspec->name;
data.count = 0;
{
const GType *otypes;
guint i;
- gint result;
+ int result;
gtk_test_init (&argc, &argv);
gtk_test_register_all_types();
{
const GType *all_types;
guint n_types = 0, i;
- gint result;
+ int result;
const char *display, *x_r_d;
/* These must be set before gtk_test_init */
return res;
}
-static gint
+static int
_count_nodes (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint res;
+ int res;
if (gtk_tree_rbtree_is_nil (node))
return 0;
gtk_tree_rbtree_test_height (GtkTreeRBTree *tree,
GtkTreeRBNode *node)
{
- gint computed_offset = 0;
+ int computed_offset = 0;
/* This whole test is sort of a useless truism. */
static void
gtk_tree_rbtree_test_dirty (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint expected_dirtyness)
+ int expected_dirtyness)
{
g_assert (node);
static void
gtk_rbtree_print_node (GtkTreeRBTree *tree,
GtkTreeRBNode *node,
- gint depth)
+ int depth)
{
- gint i;
+ int i;
for (i = 0; i < depth; i++)
g_print ("\t");
gtk_tree_rbtree_free (tree);
}
-static gint *
+static int *
fisher_yates_shuffle (guint n_items)
{
- gint *list;
+ int *list;
guint i, j;
- list = g_new (gint, n_items);
+ list = g_new (int, n_items);
for (i = 0; i < n_items; i++)
{
}
static GtkTreeRBTree *
-create_unsorted_tree (gint *order,
+create_unsorted_tree (int *order,
guint n)
{
GtkTreeRBTree *tree;
guint n = g_test_perf () ? 1000000 : 100;
GtkTreeRBTree *tree;
GtkTreeRBNode *node;
- gint *reorder;
+ int *reorder;
guint i;
double elapsed;
typedef struct {
GtkRecentManager *manager;
GMainLoop *main_loop;
- gint counter;
+ int counter;
} AddManyClosure;
static void
{
GtkRecentManager *manager;
GtkRecentData *recent_data;
- gint n;
+ int n;
GError *error;
manager = gtk_recent_manager_get_default ();
#include <gtk/gtk.h>
-static gint value_changed_count;
+static int value_changed_count;
static void
value_changed_cb (GtkSpinButton *spin)
g_assert_cmpint (value_changed_count, ==, 5);
}
-static gint adjustment_changed_count;
+static int adjustment_changed_count;
static void
adjustment_changed_cb (GObject *object, GParamSpec *pspec)
g_error ("%d chars, expected 0", n);
}
-static gint
+static int
count_toggles_at_iter (GtkTextIter *iter,
GtkTextTag *of_tag)
{
GSList *tags;
GSList *tmp;
- gint count = 0;
+ int count = 0;
/* get toggle-ons and toggle-offs */
tags = gtk_text_iter_get_toggled_tags (iter, TRUE);
return count;
}
-static gint
+static int
count_toggles_in_range_by_char (GtkTextBuffer *buffer,
GtkTextTag *of_tag,
const GtkTextIter *start,
const GtkTextIter *end)
{
GtkTextIter iter;
- gint count = 0;
+ int count = 0;
iter = *start;
do
return count;
}
-static gint
+static int
count_toggles_in_buffer (GtkTextBuffer *buffer,
GtkTextTag *of_tag)
{
GtkTextIter iter;
GtkTextTag *tag;
gboolean state;
- gint count;
- gint buffer_count;
- gint last_offset;
+ int count;
+ int buffer_count;
+ int last_offset;
if (gtk_text_iter_compare (start, end) > 0)
{
{
do
{
- gint this_offset;
+ int this_offset;
++count;
{
do
{
- gint this_offset;
+ int this_offset;
++count;
GtkTextIter start;
GtkTextIter end;
GtkTextIter mark;
- gint i, j;
- gint num_chars;
+ int i, j;
+ int num_chars;
GtkTextMark *bar_mark;
GtkTextTag *tag;
GHashTable *tag_states;
- gint count;
- gint buffer_count;
+ int count;
+ int buffer_count;
gtk_text_buffer_get_bounds (buffer, &start, &end);
GtkTextBuffer* buffer;
gboolean on_next_line;
gboolean on_end_iter;
- gint new_pos;
+ int new_pos;
buffer = gtk_text_buffer_new (NULL);
{
GtkTextBuffer *buffer;
GtkTextIter iter;
- gint offset;
+ int offset;
buffer = gtk_text_buffer_new (NULL);
GtkTextTag *bold_tag;
GtkTextTag *editable_tag;
GtkTextIter iter;
- gint offset;
+ int offset;
buffer = gtk_text_buffer_new (NULL);
static void
check_forward_line_end (const gchar *buffer_text,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextBuffer *buffer;
static void
check_word_boundaries (const gchar *buffer_text,
- gint offset,
+ int offset,
gboolean starts_word,
gboolean ends_word,
gboolean inside_word)
static void
check_forward_word_end (const gchar *buffer_text,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextBuffer *buffer;
static void
check_backward_word_start (const gchar *buffer_text,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextBuffer *buffer;
static void
check_forward_visible_word_end (GtkTextBuffer *buffer,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextIter iter;
static void
check_backward_visible_word_start (GtkTextBuffer *buffer,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextIter iter;
static void
check_is_cursor_position (const gchar *buffer_text,
- gint offset,
+ int offset,
gboolean ret)
{
GtkTextBuffer *buffer;
static void
check_cursor_position (const gchar *buffer_text,
gboolean forward,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextBuffer *buffer;
static void
check_visible_cursor_position (GtkTextBuffer *buffer,
gboolean forward,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextIter iter;
static void
check_sentence_boundaries (const gchar *buffer_text,
- gint offset,
+ int offset,
gboolean starts_sentence,
gboolean ends_sentence,
gboolean inside_sentence)
static void
check_forward_sentence_end (const gchar *buffer_text,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextBuffer *buffer;
static void
check_backward_sentence_start (const gchar *buffer_text,
- gint initial_offset,
- gint result_offset,
+ int initial_offset,
+ int result_offset,
gboolean ret)
{
GtkTextBuffer *buffer;
GtkTextBuffer *buffer;
GtkTextIter iter, start, end;
gboolean ret;
- gint offset;
+ int offset;
buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_start_iter (buffer, &iter);
signal_monitor_rows_reordered (GtkTreeModel *model,
GtkTreePath *path,
GtkTreeIter *iter,
- gint *new_order,
+ int *new_order,
gpointer data)
{
signal_monitor_generic_handler (data, ROWS_REORDERED,
test_append (void)
{
GtkTreePath *p;
- gint i;
- gint *indices;
+ int i;
+ int *indices;
p = gtk_tree_path_new ();
for (i = 0; i < 100; i++)
test_prepend (void)
{
GtkTreePath *p;
- gint i;
- gint *indices;
+ int i;
+ int *indices;
p = gtk_tree_path_new ();
for (i = 0; i < 100; i++)
{
const gchar *str = "0:1:2:3:4:5:6:7:8:9:10";
GtkTreePath *p;
- gint *indices;
+ int *indices;
gchar *s;
- gint i;
+ int i;
p = gtk_tree_path_new_from_string (str);
indices = gtk_tree_path_get_indices (p);
test_from_indices (void)
{
GtkTreePath *p;
- gint *indices;
- gint i;
+ int *indices;
+ int i;
p = gtk_tree_path_new_from_indices (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1);
g_assert_cmpint (gtk_tree_path_get_depth (p), ==, 10);
{
GtkTreePath *p;
GtkTreePath *q;
- gint *pi;
- gint *qi;
- gint i;
+ int *pi;
+ int *qi;
+ int i;
gboolean res;
p = gtk_tree_path_new_from_indices (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1);
static void
check_model (TreeStore *fixture,
- gint *new_order,
- gint skip)
+ int *new_order,
+ int skip)
{
int i;
GtkTreePath *path;
specific_bug_698396 (void)
{
GtkTreeStore *tree_store;
- gint new_order[1] = { 0 };
+ int new_order[1] = { 0 };
/*http://bugzilla.gnome.org/show_bug.cgi?id=698396 */
gboolean split_first_cap)
{
GString *symbol_name = g_string_new ("");
- gint i;
+ int i;
for (i = 0; name[i] != '\0'; i++)
{
int height,
gpointer data)
{
- gint i, j;
+ int i, j;
for (i = 0; 20 * i < width; i++)
{
{
GtkWidget *window;
GtkWidget *da;
- gint w, h;
+ int w, h;
gboolean done;
window = gtk_window_new ();
{
GtkWidget *window;
GtkWidget *da;
- gint w, h;
+ int w, h;
gboolean done;
window = gtk_window_new ();
test_resize_popup (void)
{
GtkWidget *window;
- gint w, h;
+ int w, h;
gboolean done;
/* testcase for the dnd window */
test_show_hide (void)
{
GtkWidget *window;
- gint w, h, w1, h1;
+ int w, h, w1, h1;
gboolean done;
/*http://bugzilla.gnome.org/show_bug.cgi?id=696882 */
int
main (int argc, char *argv[])
{
- gint i;
+ int i;
gtk_test_init (&argc, &argv);
return G_SOURCE_REMOVE;
}
-static gint inhibit_count;
+static int inhibit_count;
static GMainLoop *loop;
G_MODULE_EXPORT void
static void
set_border_window_size (GtkTextView *text_view,
GtkTextWindowType win,
- gint size)
+ int size)
{
GtkWidget *label;
projects / gtk4.git / commitdiff